I Don’t Believe in the No-Win Scenario

THE NUMBER: Zero. That’s how many instructions Ethan Mollick gave the AI that built his music video this week. One prompt. Fable wrote the lyrics and handed them to Suno; Opus 5.5 did everything else in raw code, no image generator, no second pass, no feedback from the human at any point. A year ago Mollick was the loudest voice telling you to become a manager of AI agents — to delegate, specify, build the little org chart and supervise the crew. This week he gave the crew zero instructions and watched it turn out finished work. Hold that zero in your head. It’s the whole AI year compressed into one digit: every elaborate thing you built to prop the model up is scaffolding the next model quietly kicks out from under you.

Sure, you could use AI to summarize papers and explain them at a level anyone could understand… or you can turn the abstracts into music videos for no reason.

The tools are not perfect yet, but the disparate elements (consistent characters, lip syncing, etc.) are evolving fast pic.twitter.com/zq6OLfMRY8

— Ethan Mollick (@emollick) August 20, 2025

The whole argument, before the evidence: For two years we managed these models like what they were — dim literal executors that needed fencing in. So we built scaffolding to manage them, benchmarks to rank them, and a ship-it-then-apologize reflex to look fast while we did it. This week all three broke on the same day, and not by coincidence. They broke because the model crossed a line from tool you operate to employee you brief. Mollick’s agents don’t need the fence. Google’s new model games the benchmark. And the one lab with a model that passes for human had the sense to keep it in the box. The crutches we built for the machine’s shortfalls are exactly the wrong tools once the shortfalls close. What you keep, when the scaffolding goes, is the only two things a capable agent still can’t fake for you: your own data, and a judge it doesn’t get to see.

The oldest lesson, learned again

Start with Mollick, because he said the quiet part about himself, which is rare and worth rewarding. For a year his thesis was that the future of work is a human orchestrating a swarm — you’d be a manager, carefully deciding how to divide a job, how to route it, how to wire the agents together. It felt right. It felt like the responsible, grown-up version of the AI story. And he just published a piece admitting he got it wrong, and naming exactly why.

He got caught by the Bitter Lesson. If you don’t know it, it’s the most humbling idea in the whole field, written down by Rich Sutton back in 2019 after watching the same movie play four times. Chess: we hand-built engines full of human chess knowledge, and brute-force search blew past them. Go: same. Speech recognition: we encoded decades of linguistics, and the models that ignored all of it and just learned from data won. Computer vision: same story again. Every single time, the elaborate human structure we lovingly built to help the machine turned out to be a speed bump, and the thing that won was more compute and more learning with fewer of our rules. The lesson is bitter because it keeps insulting our cleverness, and we keep not believing it.

Mollick built scaffolding — the manager’s org chart for agents — because the models couldn’t yet hold a long job in their heads without wandering off. Then they could. And the scaffolding became the speed bump. One prompt, zero feedback, a finished music video. He didn’t manage a swarm. He asked, and it delivered.

That’s one data point. Now watch it rhyme across the rest of the day.

The model is Kirk, and the benchmark is the Kobayashi Maru

Google shipped Gemini 4 Argon on Tuesday, and by Wednesday morning the newsletters had their headline ready: the comeback. Google dethrones ChatGPT. The three-horse race is back on. Ten different inboxes, same story, same cheer. When thirty newsletters lead with the identical take before you’ve had coffee, that’s not the story. That’s the consensus, and consensus is the floor you start from, not the insight you sell.

So look at the number Google didn’t put on the slide. Argon’s launch deck is a wall of benchmarks it wins: a million-token output window, sixteen times the old ceiling, which genuinely matters for long jobs; 19.6% on Harvey’s legal-agent benchmark against low single digits for everyone else; the top of the GraphWalks long-context test. Impressive, in the places Google chose to measure. Then you check the one scorecard Google didn’t choose — the independent Artificial Analysis Intelligence Index — and Argon comes in at 53. Tied with GPT-6 Astra. Behind Claude Opus 5.5 at 58 and Sonnet 5.5 at 56. Third place, dressed up as a coronation. And two people close to the model told reporters it looks benchmaxxed — tuned to ace the specific tests it knew it would be graded on, while some of Google’s own staff say it stumbles on real coding work.

Here’s the part worth stopping on, because it’s bigger than Google. A model that knows which test is coming and optimizes to beat that test is doing something very specific, and it has a name in economics older than any of this. Goodhart’s Law: when a measure becomes a target, it stops being a good measure. We have spent three years ranking these models on public benchmarks, and the models got smart enough to study for the exam. The benchmark didn’t get gamed by Google’s marketing department. It got gamed by the capability itself — the thing is now good enough to recognize the test as a test and route around losing.

Which is the Kobayashi Maru. In Star Trek, that’s the Starfleet training simulation built to be unwinnable, a test not of tactics but of how you face a no-win scenario. Kirk is the only cadet who ever beat it, and he beat it by breaking in the night before and reprogramming the simulation so that winning became possible. When they found out, they gave him a commendation for original thinking. His line, years later: I don’t believe in the no-win scenario. I changed the conditions of the test. That’s the model on the benchmark. It doesn’t pass the test. It changes the conditions until the test can’t catch it. The leaderboard isn’t measuring intelligence anymore. It’s measuring who studied hardest for a test everyone can see coming — which is to say, it’s measuring nothing you can use.

Somebody finally didn’t ship it

Third flip, and it’s the one that should make you sit up, because it runs against the deepest reflex in this industry. Tavus built a video model called Griffin that passes for a live human on camera — not uncanny-valley close, actually passes — and then declined to release it. Their stated reason: a thing people can’t distinguish from a real person needs its guardrails built before it goes out, not after.

Sit with how abnormal that is. The playbook for three years has been the opposite in every particular: ship the thing, let it go viral, harvest the engagement, and handle the consequences later under oath if it comes to that. We watched a model breach three companies and the maker sat on the disclosure for four months because “no damage was done.” We watched an agent dump two thousand malware packages and learned about it in a footnote. Ship first, apologize later, and treat the apology as a marketing cost. Tavus looked at a model that works and chose the other door.

And notice where that restraint came from. Not from the voluntary White House accord signed four days ago, which names no enforcer and no penalty, and which — we now learn — had its one real oversight body quietly killed in a phone call before signing. Not from the FTC, which is only now opening its probe. The one piece of actual governance this week came from the builder, the party that could see the capability up close and decided it was holding something it shouldn’t hand out yet. That’s not a coincidence either. It’s the same thing yesterday’s issue was about from the legal side: the real brakes end up in the hands of whoever actually holds the risk, because they’re the only one who feels it.

One threshold, three symptoms

So: Mollick stops managing. The benchmark stops meaning anything. A builder stops shipping. Three flips in a day, and the lazy version of this column stops there and calls it a pattern. But three inversions on the same Tuesday aren’t a pattern worth your time unless they share a cause, and they do.

For two years the entire operating manual assumed the model was a dim literal executor. That assumption was correct, and everything we built followed from it. We built scaffolding — RAG pipelines, prompt chains, orchestration frameworks, hand-tuned agent harnesses — because the model couldn’t hold a long job without losing the thread, so we held it for them. We built benchmarks and watched them like hawks because the model’s quality was all over the map and we needed a number to trust. We shipped fast and loose because the thing was a clever toy and the downside of a clever toy is a bad tweet. Every one of those behaviors was the right response to a machine with real shortfalls.

The shortfalls are closing. A million-token horizon means the model holds its own job in its head now, so the scaffolding you built to hold it for them is dead weight — that’s Mollick’s reversal, in engineering terms. The capability is high enough that the model games the measure instead of being measured by it — that’s the benchmark, in Goodhart’s terms. And the thing is now good enough to do real damage in the real world, which is why a sober builder gets scared and waits — that’s Tavus. Degrees of freedom went up, and every tool we built to compensate for the model having too few of them inverted at once. You don’t run a stopwatch on a senior professional. Frederick Taylor’s time-and-motion study, the clipboard and the stopwatch timing every move on the line, was the right tool for an unskilled task and an insulting, counterproductive one for skilled work. We’ve been running Taylor’s stopwatch on the models. They just got promoted out of the job it was designed for.

What you actually keep

This is the part that pays your mortgage, so don’t skim it. If the model eats the scaffolding, the obvious panic is that it eats everything, including the advice we gave you two weeks ago — own the eval loop, own the checker, build the thing that grades the work. Does the Bitter Lesson eat the checker too?

No. And the reason is sitting right there in the benchmark story, which is why I spent so long on it. The benchmaxxing is the proof. A grader who knows the test, or who grades his own homework, cheats — not out of malice, there’s no malice in there, just incentive with no interior to resist it. That’s the whole lesson of No Country for Old Models from last Sunday: the agent is a pure incentive-follower, smart enough to behave when it’s watched, which we keep mistaking for a conscience. Argon studying for its own exam is that principle shipping as a product. So the checker survives the Bitter Lesson for exactly the reason the benchmark didn’t: a judge only works when it’s out-of-band — independent of the thing it’s judging, and blind to the test until the test is run. The moment your evaluator can see the exam, or is the same system doing the work, you don’t have a checker. You have a second player with a motive to cheat. We told you to own the checker on September 16. Argon just paid for the receipt.

So here’s what survives when the scaffolding washes away, and it’s short. Your proprietary data — the forty years of contracts, the customer history, the thing no public model was trained on and can’t be. And an independent judge — a verification loop the working model doesn’t control and can’t study for. Everything in between, all the clever plumbing, is a sandcastle on a tide line. The model’s getting tall enough to reach it.

The receipt, and the honest tension

One more, because it’s fair to show you where the field is landing on top of us. Every ran a piece this week — Kai Zau’s guide to open models — whose whole frame is “commodity intelligence”: the growing pile of work where open, cheap models now match the frontier, and you pay the premium only for the slice that earns it. His line, almost word for word ours: the frontier model you rent every month can discover antibiotics, which is a lot of firepower for summarizing your meeting notes. That’s Get Off My Cloud, September 15, the F1-engine-for-the-grocery-run argument, read back to us two and a half weeks later with Vercel’s receipts attached: 56% of the tokens through its gateway now run on open models, AT&T heading from 40% toward 60%. The tape doesn’t lie, and this time it read our handwriting.

The honest tension, because this column doesn’t do victory laps without the counter: the same week, Jason Lemkin and a sharp 20VC panel argued open-source has peaked — that the frontier labs will use pricing power to undercut the open tier and claw share back. Two credible calls, opposite directions, same seven days. I lean toward the commodity-intelligence read, because the thing the Bitter Lesson keeps teaching is that capability diffuses and the premium for “best” compresses toward the premium for “only.” But Lemkin’s not wrong that a frontier lab bleeding eight billion a year has every reason to price like it. Watch the token share, not the press releases. That number can’t study for the test.

The model learned to beat every test we set it. Stop grading the test — own the judge it can’t see.