Anthropic Deleted the Off Switches

324 to 1. That is the input-to-output token ratio of a typical Claude Code session as of this month, according to telemetry Anthropic published on September 24. In March it was 189 to 1. In six months, the model's own output has shrunk to roughly 0.3 percent of the tokens moving through a coding session — everything else is context the harness re-sends, tool results, and cached prefix. The modern coding agent is a reading machine that occasionally emits a diff.

Five days earlier, Anthropic shipped Claude Opus 5.5, and most coverage treated it as a routine flagship refresh: better benchmarks, 20 percent cheaper. The part that matters to anyone who builds agent infrastructure is buried in the platform docs under "breaking changes." Four of them. Thinking can no longer be disabled. Forced tool use now returns an error — tool_choice accepts only auto and none. Thinking blocks are tied to the specific model and conversation, so switching models mid-task discards reasoning context. And the text a model writes between tool calls now comes back inside thinking blocks whose text is empty at the default display setting — which means any application that streamed that text to users as a progress indicator silently went quiet.

Read together, the telemetry and the breaking changes are one story. The session became a long, context-heavy, mostly-cached read. The model got good enough that Anthropic removed the harness's levers over how it works — and kept only the levers over how much it works. This is not a model release. It is a transfer of authority from harness configuration to model policy, executed through the API contract itself.

What Anthropic's Own Numbers Say Happened

The September 24 post is the most candid vendor telemetry on agentic coding published this year, and every line of it points the same direction. Comparing March to September 2026 across aggregate Claude Code usage:

• Claude works 3.3x longer on each prompt, with more than 40 percent more model calls per prompt.
• 68 percent fewer interruptions — humans are stepping in less.
• Context per request grew 2.6x, driving the input:output ratio from 189:1 to 324:1.
• Developers are about twice as likely to have a tool server connected or use a skill, and a third less likely to paste text into a prompt.
• Despite the heavier context, input that misses the cache decreased by more than 50 percent — Claude Code got materially better at not breaking its own prefix.

That is the profile of a workload that stopped being a chat and became a job. Sessions run long, touch many tools, and re-read the same large context repeatedly. And when the work looks like that, the two things a harness engineer used to control directly — whether the model deliberates, and which tool it must call next — are not just unnecessary. They are actively expensive, because overriding a model that knows what it wants to do next produces worse trajectories than letting it proceed.

So Opus 5.5 removes them. Adaptive thinking is always on; the model decides how much reasoning each task needs, and your control surface collapses to a single effort parameter — low through high, default medium — that sets the budget instead of the behavior. You cannot tell it to stop thinking. You cannot tell it which tool to call. You can tell it how hard to try.

The Numbers That Justify the Removal

None of this would matter if the model hadn't earned it. The benchmark story is unusually strong, and unusually honest about its own limits:

• Terminal-Bench 4.0: 66.4 percent, versus 52.3 for Opus 5, 57.9 for GPT-6 Astra, and 55.8 for Anthropic's own Fable 5.1 — a 14-point jump over the predecessor on agentic terminal work.
• FrontierCode v1.1 (Main): 54.6 percent at default effort, beating GPT-6 Astra's 53.3 — at roughly one-fifth the cost per task.
• CursorBench 4.0: 52.5 percent at default effort, eleven points over GPT-5.6 Sol's 41.7, at about a third of the cost.
• An early tester audited and fixed a 200,000-line codebase in under three hours, where Opus 5 took over 20 hours and 2.5x the tokens.
• Translating HAProxy from C to Rust: both Opus 5.5 and Fable 5.1 passed nearly all regression tests, but Opus 5.5 finished in 9.5 hours versus 12, at 51 percent less cost.
• In one internal test it ran autonomously for more than 18 hours across six repositories; on internal research reports, 16 of 18 met Anthropic's quality threshold — against zero for Opus 5 and zero for Fable 5.1.

Pricing follows the same logic. Input dropped 20 percent to $4 per million tokens, output to $20 — but the number doing the real work is the cache read, cut 60 percent to $0.20 per million. When output is 0.3 percent of traffic and the majority of cost is re-read context, the cache price is the price. Anthropic also added a one-hour cache lifetime on API keys and made forked subagents start from the parent's cache instead of paying for the same context again — and, tellingly, you can now change effort levels mid-session without resetting the cache. The one control lever they kept you, they made sure it doesn't cost you anything to pull.

Anthropic itself cautions that at this capability level benchmark margins have become a less reliable guide to real-world differences, and that the gap between Opus 5.5 and Fable 5.1 in daily use is narrower than the scores suggest. Good. That caution is correct, and it is also the point: when benchmarks stop discriminating, selection pressure moves to how the model behaves inside your harness — which is exactly where Opus 5.5's changes concentrate.

The Quiet Breaking Change That Broke Real Products

Of the four breaking changes, the one that will bite hardest is the subtlest. Previously, text a model produced between tool calls arrived as ordinary content. Applications built progress UIs on it: "Examining the test failures now…" streaming by while the agent worked. Under Opus 5.5, that text comes back inside thinking blocks — and at the default display setting, the text is empty. No error. No deprecation warning. The request succeeds, the agent keeps working, and the human watching the terminal sees nothing between tool calls.

This is a new class of harness failure worth naming: the response-shape break. Nothing fails programmatically, so your tests pass, your error rates stay flat, and your product degrades in the one dimension no dashboard tracks — the user's sense that the agent is alive. Every harness that parses model output structurally, not just every harness that uses the removed parameters, is exposed to this on every model generation. If your test suite asserts on response shape and content-block roles, you caught this on day one. If it asserts on task outcomes only, you are finding out from your users.

The model-bound thinking blocks are the same story at the architecture level. Reasoning context now belongs to the specific model and conversation that produced it; switch executors mid-task and the reasoning is gone. This is creator co-adaptation — the harness-model coupling that HarnessDev measured and Nvidia's SoL-Pi worked around — now enforced by the API contract rather than emerging from optimization. Anthropic is telling you, in schema, what the research literature spent September proving: the harness and the model are one system, and hot-swapping the model is no longer a supported operation.

What the Harness Engineer Still Controls

Most people will read this release as "the model got smarter and cheaper." The structural reading is more interesting: the set of things a harness controls just got strictly smaller, and what remains got more valuable.

Strip away the removed levers and look at what Anthropic actually shipped alongside the model. A classifier that screens every action before it runs. An open-source sandbox security teams can audit. Code review that catches vulnerabilities before merge. The one-hour cache lifetime. Subagent cache forking. The effort parameter that survives a session. That is the new control surface, and notice where it sits: not over the model's reasoning, but around its actions — gating, budgeting, and memory, instead of steering. The harness's job is no longer to direct the model's next step. It is to decide what the model may touch, how hard it may try, and what it remembers.

This is the continuation of a line this blog has been tracking all year — Anthropic deleting 80 percent of Claude Code's system prompt because the model had internalized it, LangChain cutting Deep Agents' base payload by 65 percent, Nvidia's search discovering that the surviving harness mechanisms were all compression and routing. Each step removed harness machinery the model had absorbed. Opus 5.5 removes the last of it: the parameters that made the model a component you could commandeer. The discipline formerly known as prompt-and-parameter engineering is being folded into the model, and what's left — the environment design, the budgets, the evals — is the part I've been calling harness engineering all along. The book covers this division in depth; the short version is that authority doesn't disappear when you delete a lever. It moves to whoever designs the environment the lever used to sit in.

What to Do This Week

1. Grep your codebase for tool_choice before you migrate. Any request that forces a specific tool or "any" will error against Opus 5.5. If you were using forced tool use to implement structured extraction or guaranteed side effects, move that logic into tool schemas and let the model select — or move it out of the model entirely, which for deterministic operations is where it always belonged.
2. Replace your thinking toggles with an effort ladder. If your harness has branches like "thinking on for hard tasks, off for cheap ones," those branches are now dead config. Rebuild them as effort settings — and since effort changes no longer bust the cache, you can adapt mid-session per task instead of provisioning two session classes.
3. Pin your display semantics and test response shape. If you stream inter-tool text as progress, set the display value that returns it, explicitly. Then add a contract test that fails when content-block roles change shape — one test, run against every new model version, would have caught this break before your users did.
4. Re-run your bill math with the new asymmetry. At $4 input, $0.20 cache reads, and a 324:1 ratio, the economics reward a different set of habits: longer sessions over fresh sessions, subagent forking over context re-sending, one model per task over mid-task switching. Anthropic's own advice is to pick the model at session start, compact before stepping away, and set the one-hour cache lifetime. Run /usage in Claude Code, find your cached-read share, and protect it like the KPI it now is.

A 324:1 ratio and a model you can no longer tell what to do — those are the same fact. When the output is 0.3 percent of the traffic, the model isn't the tool anymore. The session is the tool, the harness is the handle, and the vendor just reminded everyone who owns the blade: effort in, action gated, reasoning bound. The off switches weren't taken from you because the model is fragile. They were taken because you weren't using them right, and now the API won't let you.