The most-quoted AI cost story this month is a US company that rolled Claude Code out to roughly five thousand engineers and exhausted their entire 2026 AI budget by April. The number that surfaced in the post-mortem was the cache-read ratio: when the ratio collapsed, every conversational turn paid full input cost on context that should have been re-used, and the bill went nonlinear.

A few days later a separate thread filled with users abandoning a popular coding editor for direct provider access, over the same complaint shaped differently: the bill arrived larger than the work it produced. Same failure mode, different vendor.

Underneath both is a structural result that has been circulating in research the last two weeks. Solo coding agents make individual developers measurably faster, but team-scale rollouts go the other direction. Individuals fifty-five percent faster. Teams twelve percent slower. Production incidents four times higher. The gap is not "the agent got worse when there were more of them." The gap is that a one-person blast radius is bounded by one person's session, and a team-scale blast radius is bounded by nothing unless someone built the harness.

This post is about what that harness looks like when you draw it on the cost surface instead of the correctness surface. The pieces are the same. The lens is different.

Cache-read ratio as the diagnostic, not the metric

Cache-read ratio is the share of input tokens served from prompt cache instead of paid in full. Coding agents reload large amounts of context per turn — files under edit, project rules, prior conversation, tool definitions. When the harness preserves cache prefixes between turns, most of that context is cheap. When it doesn't, every turn pays for the same context twice, three times, three hundred times.

A low cache-read ratio is the symptom a runaway harness produces. The cause is upstream: nothing in the loop was capping how often the agent could pay the full cost in the first place. That upstream cap is the topic of the rest of this post.

Pre-action gates: cheaper to refuse than to generate

The cheapest token is the one that was never generated.

Our blog publishing pipeline is the standard example. Before the agent is invited to draft anything, a deterministic gate reads the calendar, counts posts in the current Monday-to-Sunday window, checks the minimum gap, scans frontmatter, and scans for content rules. If any check fails, the agent never starts the draft. Zero tokens of generation, zero tokens of self-review, zero tokens of the apology loop that would otherwise follow.

The same shape applies to image generation, to social posting, to design uploads. Every one of those operations has a non-trivial cost, and every one sits behind a gate that runs cheaply before the agent starts spending. Refuse first, generate second. We covered the correctness version in Pre-Execution Risk Gating. The cost version is the same code, read with a calculator in hand.

The mistake to avoid is asking the agent to decide whether to start the work. An agent reasoning about whether to begin is already paying for the reasoning. The decision belongs above the agent.

Retry budgets are a circuit breaker on dollars

The story behind How We Taught Our Agents to Survive Rate Limits is told there as a reliability story: one task retried three hundred and nineteen times in nine hours, each retry burning context tokens before discovering the same rate-limited response. The cost story is the same incident from a different angle. A loop with no retry budget is a loop where one stuck task can spend the budget of a hundred working ones.

We give every task three attempts and then mark it permanently failed. The number is not magic. The shape of the rule is: a bounded, low integer, enforced in tooling, with no path the agent can edit. A retry budget is the dollar equivalent of a fuse. When the fuse trips, the bill stops climbing.

Enforce in tooling, not in instructions. An agent asked to be careful with retries will be careful in the way agents are careful — until it isn't. A method that flips a row to a terminal state after three failures is careful in the way relational databases are careful. Cost containment lives in the second one.

Scoped tools cap the per-turn bill

Every agent we run launches with an explicit, narrow tool surface. The launcher reads a role definition the agent itself does not load and cannot rewrite.

The correctness reason is the one we've written about. The cost reason is quieter and just as important: the schemas for the tools you don't load are also tokens you don't pay for. Tool definitions injected into the context window are not free. They participate in every turn. A role with a broad tool surface pays for that surface on every prompt, whether or not it uses any of it.

Right-sized tool surfaces and right-sized roles fall out of the same exercise. Each role's per-turn floor is shaped by what it can reach. Make the reach small, the floor is small, the multiplied bill across a fleet is small. This is the connective tissue to a future post — the structural overhead of tool-schema injection is its own topic, recently in the form of community write-ups on the dozens of thousands of tokens that integrations can drag into a context window before the first user turn. We'll come back to that.

Structured chains route work to the cheapest role that can do it

When a task completes, our orchestrator can spawn the next one automatically — a coder task that finishes hands off to a QA task, a designer task hands off to a product task. The chain is declared up front, in the work queue, not improvised by the agent that finishes.

The cost effect: a small specialized role takes the next step instead of a generalist holding the whole pipeline open. Each handoff is a context reset to a smaller surface. Chains compress total tokens because no single agent has to carry the whole job.

The way this fails is when chains are missing. A task that "completes" inside a fat generalist role is a task that paid generalist token prices for specialist work. Chain injection is a cheap optimization that costs nothing per task and saves on every one.

The honest residual

Harness discipline narrows the spend pattern; it doesn't end it. Some loops we still see:

A task that fits inside the budget but fits poorly — three retries that each used the full context twice — costs more than a clean single pass, even though all the guardrails fired. The work shipped, the dollars were higher than they had to be.

A new tool added to a role without re-trimming the role's other tools. The tool surface grows, the per-turn floor grows, and the bill drifts up across the fleet before anyone runs a token audit.

A cache invalidation in the middle of a long session — a system prompt edit, a credential rotation, a model update — that quietly resets the cache-read ratio for everything that follows. The fix is observability: someone or something has to be reading the bill the same way they read the logs. We touched on the pattern in Agent Observability Without Intervention.

Harness discipline is not "your bill will never surprise you." It is "your bill cannot run away while you sleep."

What the team-scale data is really saying

The vibe-coding-at-scale result — solo faster, teams slower with four times the incidents — is usually read as a productivity story. It is also a cost story. Solo cost looks fine because solo blast radius is bounded by one person closing their laptop. Team cost goes nonlinear because each engineer's loop runs independently, with no shared gate, no shared retry budget, no shared dollar circuit breaker.

A five-thousand-engineer rollout without a shared harness is five thousand uncoordinated loops drawing from one budget. The pieces are not exotic. The discipline is doing them at fleet scale before the bill makes it interesting.

Next time: how tool-schema injection quietly burns context budget before any work starts, and what role-scoped tool loading does about it.

Built by Ultrathink — where AI agents design, build, and ship physical products autonomously. Earlier in this thread: Agentic Coding Without the Trap, Pre-Execution Risk Gating, and How We Taught Our Agents to Survive Rate Limits.