the gradient was lying to you the whole time
Week ending June 5, 2026.
Nobody demoed a talking avatar this week, thank god. Instead we got the boring, load-bearing stuff: how RL loops silently corrupt themselves, whether models can actually hack an app when you stop grading their homework, and who ends up paying for all this intelligence. That's the good timeline. The launches are getting quieter and the plumbing is getting honest.
The unifying thread is that coding agents turned out to be the one market that will pay a real premium for marginal intelligence. Which means the money is now in the harness, the training loop, and the per-result cost — not the leaderboard screenshot. So let's look under the hood, because that's where everything interesting happened.
the RL loop you wrote on a Friday is broken
The piece I loved most was Agentic RL: Token-In, Token-Out Done Right. The claim is precise and a little horrifying: if your multi-turn RL loop parses a model's tool call and then re-tokenizes the updated conversation for the next turn, you are backpropping on tokens the model never sampled. Decoding isn't injective — BPE has multiple valid segmentations, JSON whitespace wiggles, false vs False — so the round-trip drifts. No crash. Just a quietly wrong gradient.
The fix is a single invariant: never re-encode tokens you've decoded. Keep the sampled tokens in a buffer as the source of truth, parse only for routing, and use the template just to append the tool response. The load-bearing property is that a chat template is prefix-preserving for tool messages — and it turns out 18 of 19 popular open-weights families already satisfy it by accident. This is exactly the kind of typed-contract, twelve-line-property-test discipline I trust more than a pretty loss curve. Curves lie. Invariants don't.
orchestration you can actually read
On the same theme of inspectable structure, pi-dynamic-workflows is a small Pi extension where the model writes a JavaScript script that fans work across isolated subagents, with typed globals (agent, parallel, pipeline, phase) and live progress. Crucially the script runs in a Node vm sandbox with Date.now, Math.random, and require deliberately removed, so runs stay reproducible. Prompt-as-architecture gives you a black box; this gives you something you can step through in a debugger. That's the difference between orchestration and vibes.
what happens when you stop self-grading
Then there's the eval that survives contact with reality: I built a vulnerable app and spent $1,500 seeing if LLMs could hack it. Deliberately vulnerable book-review app, a Firebase misconfig hiding behind a hardened API, ten runs per model with Wilson confidence intervals and honest $/solve numbers. GPT-5.5 solved 7/10 at about $9.46 a solve. DeepSeek V4 Pro got 3/10 for 62 cents. Gemini refused outright. Claude Opus got tantalizingly close and then hit late safety refusals.
The caveats are the whole point — self-approved research access, providers with outages, ~50% of the spend on failed runs. This is adversarial, wide confidence intervals and all, and it's the exact opposite of a self-graded demo. Note the spread: cheap models can be competitive, and the expensive ones aren't automatically better hackers.
who pays for the intelligence
Which brings us to economics. Nathan Lambert argues in Open and closed models are on different exponentials that coding agents are the first market that reliably pays large margins for better intelligence, so closed labs will ration their best models via API — rolling them out late to protect token supply and dodge distillation. Open models ride a slower, broader diffusion curve, commoditized across many serving stacks. I buy the shape, though "$2–10T valuations" is the kind of number that only reconciles if the buildout keeps getting financed.
And the buyers noticed. Tomasz Tunguz's Intelligence Per Dollar flags Microsoft adding average token usage to a release card — a coding model hitting SWE-Bench numbers on a third of Haiku's tokens. Benchmarks are now two-dimensional. Uber capped AI spend after four months; Salesforce is reportedly dropping $300M on tokens. Tokenmaxxing is over. Every layer now has to price the way the customer thinks: per closed ticket, per shipped PR.
what I'd do Monday
- Add the prefix-preservation property test to CI for every model you fine-tune. It's twelve lines and milliseconds. Do the same round-trip check on your own agent loop before trusting a single reward curve.
- Start logging $/result, not tokens. If you can't say what a resolved ticket costs, you can't budget, and your finance team will find out the hard way.
- Run one honest adversarial eval with confidence intervals against your own app. Assume the cheap model might tie the expensive one.
vocabulary inflation
TITO (Token-In, Token-Out): the invariant that you train on exactly the tokens the model sampled — never re-encode what you decoded. Prefix-preserving: a chat template where appending a tool result extends the render token-for-token. Tokenmaxxing: gaming benchmarks by burning more tokens; now a liability. Intelligence per dollar / tokens-per-result: the buyer's actual question, finally showing up on release cards.