Distill AI · 2026-11-16
Keys: space/K play-pause · J/L jump 10s · arrows on the waveform nudge 5s
UC Santa Barbara physicist Nathaniel Craig says GPT-6 Astra took the lead on the detailed proof in his preprint proposing a candidate lattice definition of the Standard Model, while DeepMind's AlphaProof Code delivered the first AI-driven verification of Signal's protocol at implementation level. Google turned Gemini 4 into a tiered family: the Carbon flagship at general availability, the speed-focused Hydrogen edging Argon 51 to 50 on the Artificial Analysis Intelligence Index, a Decisions API that scores routing choices in a single forward pass, and an MKA benchmark graded by a non-Google autorater. OpenAI shipped ChatGPT Wallet with American Express, Mastercard, and Visa — agents pay without ever holding card details, gated by a biometric check on every purchase — plus a Businesses in ChatGPT beta aimed at its claimed 1.2 billion weekly users. OpenAI's own research with Upwork found the freelance categories most associated with ChatGPT use losing posting share, even as vendor customer stories touted compressed timelines. Anthropic's engineering team warned that safety evals game easily and should borrow psychology's replication-crisis reforms.
The full episode transcript, timed to the audio. Click any line to jump there; the current line lights up while you listen.
Physicist Nathaniel Craig says GPT-6 Astra took the lead on the detailed proof in his new paper, a candidate lattice definition of the Standard Model.
Took the lead. Craig had the strategy, the model turned it into a construction, and the proof itself was the machine's work.
When the model leads and the human directs, who is the author, and who checks the work?
Hold that thought, because the rest of the week answers it in pieces — some reassuring, some not.
Welcome to Distill, the AI edition. We read what the AI leaders and labs publish so you don't have to.
It's Monday, November 16th. This week Google turned one model release into a product ladder, assistants got payment rails, and OpenAI published research that tempered its own hype.
We start with the science posts and who checks the work, spend the middle on the Gemini 4 stack and the wallet layer, take a fast lap through the rest, and close with the three things worth keeping.
The labs published two science posts this week, and between them they redraw a line — who does the work when AI does science.
Craig's post is the provocation. Where did it land?
On a brand-new OpenAI science blog, as the debut post. The subject is a candidate lattice definition of the Standard Model — candidate meaning proposed, not proven — the theory rebuilt on a discrete grid, where the math becomes computable.
And is the physics itself a big deal?
The post frames it as a step toward putting the Standard Model on a lattice, and calls it that much and no more. The authorship question is the bigger signal for us.
Why does a lab want a science blog in the first place?
Because how scientists work with models is becoming its own discipline, and the lab that hosts that conversation helps set what counts as authorship. It's positioning, and smart positioning at that.
How solid is the credit split — strategy human, proof machine?
The preprint has been public since October, so the construction is there to check — the math is verifiable even where the credit is not. The division of labor is Craig's own account, single-source, and that's the one part of this story to hold loosely.
DeepMind's entry is the verification side. AlphaProof Code verified Signal's protocol, and the company says that's the first AI-driven verification of a widely deployed cryptographic protocol at this depth.
Deeper still: the first implementation-level verification of such a protocol by any method, human or machine. Implementation-level means the shipped code gets checked, not just the design — and in security, the shipped code is historically where failures live.
Why should an engineer who doesn't ship crypto care?
Because the pattern transfers. Human-reviewed specifications plus machine-checked code is the audit shape for anything critical — medical software, infrastructure, trading systems — and it just got a flagship demo on one of the most widely deployed protocols there is.
What is AlphaProof Code mechanically?
A framework chaining several models into one pipeline. Humans review the specifications; agents powered by Gemini Carbon, Google's new flagship, do the machine work.
So both posts put people on strategy and specs, and models on the grind.
Exactly, and what's moving is the verb. "Assisted" and "took the lead" name different divisions of labor, and a debut post whose verb is "took the lead" is the signal I'd track from here.
Which is also the question for Google's biggest release this week, with one twist. There it isn't the proofs getting checked — it's the benchmarks.
The most revealing thing Google shipped this week wasn't a single model. It was a ladder — a capability flagship, a speed tier, a control-flow API, and a referee benchmark, each rung aimed at a different job.
A ladder how — same family, different jobs?
Same family, different shapes. A Search query and a hard reasoning task don't share a latency budget or a price ceiling, so one shape can't serve both.
The model release is turning into a product catalog. Name the rungs.
Gemini 4 Carbon is the flagship, now at general availability, billed as the strongest model in the family and carrying top spots on CursorBench, on Perplexity's WANDR, and on Zapier's AutomationBench.
Those are all benchmarks the vendor chose — the company that built the model decided which tests to cite. Impressive, but not yet convincing.
Keep that filter, because the next rung needs it too. Days after Carbon came Hydrogen, a speed-and-efficiency tier for everyday coding and agentic workflows, landing in Search and the developer tools.
And the number is thin — Hydrogen edges Argon fifty-one to fifty on the Artificial Analysis Intelligence Index.
On that margin, Google's Search VP calls Hydrogen the biggest model upgrade to Search yet. The superlative is marketing; the distribution logic underneath isn't — a model inside Search only works if it adds less latency than users notice, and that's Hydrogen's whole job.
So the strategy is matching model shape to job, not one model to rule them all. The rung I care about most isn't a model at all — what does the Decisions API do?
It scores closed-set choices — tool selection, routing, policy checks — in a single forward pass, and returns probabilities and confidence scores alongside the answer.
That's a different latency and cost shape than how agent routing works now, where the model generates its way to a decision one token at a time.
Right, and the difference compounds. An agent loop makes dozens of small decisions per task, and today each one costs a generated response. A single scored call makes it affordable to put a model in front of every routing decision, and the confidence score tells the loop when to escalate instead of guess.
Where would you point it first?
At the boring middle of agent stacks — the router, the gate, the retry logic — the places where generated prose is pure waste.
So cheaper decisions, taken more often. The fourth rung is the referee: the MKA benchmark — the Multimodal Knowledge Agent benchmark — built with Artificial Analysis, grading agents on visually complex, expert-defined knowledge work.
Expert-defined meaning the tasks come from practitioners, so the benchmark is shaped like real knowledge work rather than a quiz; visually complex meaning the agent has to read screens, not just text. The governance detail is the autorater, the model that grades the agents — it's built on a non-Google model, so Google co-wrote the exam but didn't grade it.
That's a partial hedge, and I'll take it. It doesn't fix Google writing the questions, but a non-Google grader is more independence than the flagship's benchmark sweep got.
The actionable read: pick the rung for the job — flagship for hard reasoning, speed tier for high-volume work, Decisions API for routing and policy checks.
Ladders need somewhere to climb, and this week the labs found it — your wallet.
OpenAI announced ChatGPT Wallet, built with American Express, Mastercard, and Visa, and billed as the first wallet that lets agents pay without access to actual card details.
Every purchase runs through a biometric check — Face ID or fingerprint — and the rollout reaches US Pro subscribers first, in stages.
The design is the news, not the launch. The agent gets a way to pay, not a number to steal, and a per-purchase biometric gate means no standing authorization to abuse.
So a compromised session costs you one purchase, not your card. About that "first," though — Google made Wallet connectable inside Gemini's Personal Intelligence the same day, with an optional Plaid link to your bank.
Fair hit. Google's is a connectable app for finance insight; OpenAI's is a transaction rail for agents. Different jobs, one news cycle apart — the rails are arriving whether the superlatives survive or not.
Why do the card networks want inside a chat window?
Because chat is where intent starts — the distance from "find me one" to "buy it" is collapsing, and the networks intend to own that rail rather than watch it get built around them.
Alongside the wallet, OpenAI opened the Businesses in ChatGPT beta: verified organizations, self-serve product feeds, and aggregated discovery insights into what buyers are looking for.
It's addressed to a claimed 1.2 billion weekly users. Even discounted, that's the storefront taking shape — if you sell online in the US, verifying your organization there is today's task, and the Wallet rollout is the one to track.
The tooling layer moved the same week. DeepSeek exposed its consumer app's machinery — cited web search, file parsing, link reading — through parameters on its deepseek-flash API.
That resets build-versus-buy math for agentic features. When cited search and file parsing are an API parameter away, the case for building them in-house thins out, and the differentiator moves to what you stack on top.
And the citation part matters — an agent that shows its sources can be audited instead of trusted, which is the kind you can put in front of customers.
Big claims all the way through — which is why the week's most careful number is the one OpenAI published against itself.
It's the economic research OpenAI did with Upwork, and it points the other way from the growth story.
What's the finding?
The forty-three work categories most common in ChatGPT use lost share of Upwork postings — out of sixty-three matched categories.
The authors call it a capability overhang: the AI-linked categories lost ground even as the models improved, and ChatGPT use alone doesn't explain the loss.
Why should an engineer care about freelance postings?
Because freelance marketplaces reprice skills first — clients vote with job posts. Posting share is the fastest public read on which tasks are actually moving, before the shift shows up anywhere slower.
Meanwhile the customer stories rolled in all week — compressed timelines, self-published, the vendor's own accounting.
Both things are true at once. The deployments and the data don't conflict — they're just held to different evidence standards.
Anthropic's engineering team supplied the frame for reading all of it. Safety evals, they say, are easily gamed and under-documented, and the field should borrow psychology's replication-crisis reforms.
Concretely: pair methods experts with domain experts, isolate the evals from the internet so they can't leak into what a model has already seen, and document the designs. An eval nobody can re-run is a claim, not a measurement.
Why borrow from psychology specifically?
Because psychology ran this experiment on itself — findings that looked solid until independent replication checked them — and wrote the fixes down.
If your deployment gates on evals, run that checklist today.
Audit first, adopt second — a good rule for everything else that shipped this week, starting with a genomics model.
DeepMind's AlphaGenome 2 reads DNA with context: condition on tissue and cell type, and it learns how the same genome is read differently across cells. Same playbook as the science posts — flagship model, real domain.
Before Carbon reached general availability, Google ran a two-week preview program called Fairwind with cyber defenders — security got the flagship first.
Shield deployed GPT-6 Astra for technicians handing off legacy portal work — the model operates the same screens a technician would, on portals with no API at all. Computer use in production; a pilot on your own back office is now reasonable.
Amplitude reports its proactive agent Wave, running mainly on OpenAI models, now ships product improvements in a day or two against roughly a month before.
Holiday Extras rebuilt its main mobile app with Codex on a timeline the company calls far shorter than its original estimate.
And Cogent Security reports sharp drops in time-to-remediate at enterprise customers running its Cyber Defense Factories.
Each of those is worth a search if it touches your stack.
Three things should outlast the details.
First, releases are ladders now, so "which model is best" is becoming the wrong question. The durable skill is matching the rung to the job — and reading every ranking with the referee in mind, because whoever graded the test decides what the ranking even means.
Second, the rails matter more than the wallets: design choices — what the agent can touch, what needs a check — decide how much trust agent commerce gets to borrow.
Third, weight every number by who audited it. This week the wins and the doubt came from the same company — that asymmetry is the tell to watch for in every vendor announcement ahead.
Sources and links for everything you heard are in the show notes.
That's the week.
Catch you Wednesday for the Hacker News edition.