The context bill, and where coding agents break

Claude Code sends about 33,000 tokens to Anthropic’s endpoint before it has read a word of your prompt. OpenCode, cold-starting the same task, sends roughly 7,000. That four-to-five-times gap is what systima found after logging every request between each agentic tool and the API and reading back the usage blocks the endpoint returns. The difference is harness scaffolding and cache strategy, not the code you asked for. It is a small study with one caveat the authors flag near the end, but the direction is unambiguous, and it puts a number on something most people only feel as a usage meter climbing faster than the work explains.

The bill compounds the moment an agent reaches past its own context and onto the web. A developer building a stealth-browser MCP measured the raw cost of the pages agents routinely pull: an average Wikipedia article runs 68,240 tokens of raw HTML by tiktoken, and Nike’s homepage 353,000. Claude Code’s webfetch handles the easy case, collapsing that Wikipedia page to around 950 tokens. On JavaScript-rendered or anti-bot pages it returns nothing, at which point the agent dumps the raw HTML back into context and still fails, sometimes falling back silently on stale training data without saying so. In the same benchmark the cleaned-up path returns that JS content in 285 tokens, and a Nike 403 becomes about 700 tokens of usable text.

If the problem is what agents carry, the question is what to keep. Shared Selective Persistent Memory makes the sharpest version of that argument: persist four categories of context across sessions (task specifications, data schemas, tool configurations, output constraints) and throw away the session-specific reasoning traces. In three enterprise scenarios that selective memory reached 96% task completion, against 79% with no memory and 71% when the full conversation history was persisted. The last number is the interesting one. Keeping everything actively degrades the agent by biasing it with stale traces, so full-history persistence loses to starting from zero. A companion zero-token refresh, which decouples the generated program from the live data it runs on, cut recurring-update task time by 14x and per-invocation token cost by 97x against re-injecting raw data.

The other thing the last day made concrete is that failure has a shape, and we mostly measure it at the wrong end. Failure as a Process collected 3,843 CLI-agent execution trajectories from seven frontier models across three scaffolds (OpenHands, MiniSWE, Terminus2) on Terminal-Bench, then hand-annotated 1,794 complete runs covering more than 63,000 steps. The pattern across 14 findings: failures are predominantly epistemic, the agent acting on a wrong belief about the environment; they usually start in the first few execution steps; and they stay invisible until recovery is no longer possible. Judging an agent only by its final diff misses the moment the run actually went wrong, which is early.

That early-error problem gets worse the longer the agent runs. SWE-Milestone reconstructs verifiable milestone DAGs from real commit logs and asks agents to work a stream of milestone-level tasks, the way software actually evolves, instead of one isolated ticket. Across 12 frontier models and 4 frameworks, scores that clear 80% on one-off tasks fall to at most 38% once the tasks chain and errors accumulate. The gap between those two numbers is the technical-debt tax that single-task benchmarks never charge. A related finding on the generation side: SCATE documents “lazy generation,” where agents writing tests terminate early and avoid the hard programmatic logic, leaving coverage thin, then trains a supervisor to push them through it at controlled cost.

Two measurements worth carrying forward: how much of an agent’s token bill is harness rather than task, and how fast its accuracy decays once the work stops being a single isolated problem. Both are cheap to measure once you decide to, and both are invisible from the final answer.