Appearance
AI Coding Agents Got Cheaper. They Didn't Get Easier to Own.
Anthropic just shipped Claude Opus 5.5 with a pricing model built for one specific observation: coding sessions are longer, they eat more context, and most of your token bill is re-reading things the model has already seen. The same week, a satirical Reddit post about chatty coding agents blew up in r/LocalLLaMA, and a GitHub repo showing how to ship the same 202 agents to seven different harnesses started trending.
Those three things look unrelated. They're the same story. The economics of AI-assisted coding stopped being about generating text. It's now about attention: the model's context, your attention, and who owns the output when the session ends.
Your agent reads more than you think
Anthropic pulled aggregate telemetry from Claude Code between March and September 2026. Prompts per session stayed flat, but context per request grew about 2.6x. Developers are running the same number of turns while pointing agents at bigger, more open-ended jobs: multi-file migrations, incident response, whole-module refactors.
That changes what the bill looks like. Agentic work is dominated by re-reads. The model reads the relevant files, then reads them again after each edit, then the subagent reads them, then the review pass reads them. Cache reads now make up the majority of agentic token cost. Opus 5.5's pricing targets exactly that: a 20% cut on input and output tokens, and a 60% cut on cached reads.
Key numbers from the Opus 5.5 update:
- 60% cut in cached-token reads, the bulk of agentic spend
- 20% cut on regular input and output tokens
- 2.6x growth in context per request over six months
- 30% faster output than Opus 5
- 50%+ drop in cache-missing input after the harness fixes
The 2.6x context growth makes the 60% cache cut worth more today than it would have been six months ago, because more of every bill is now re-read context. Run /usage in Claude Code and you'll see it: cached reads dominate. As of publication, a cached token on Opus 5.5 runs about a fifth of what competing models charge.
The harness work matters too. Anthropic made changes that should have increased cache misses over time: a one-hour cache lifetime for API keys and cloud providers, forked subagents inheriting the parent's cache instead of paying for the same context again, and mid-session effort changes on newer models that don't reset the cache. Instead, cache-missing input dropped more than 50%.
Then the second economic shoe drops: turns.
Cost is moving from tokens to turns
A cached token is cheaper than a fresh one. A turn that never happens is free. Opus 5.5's behavioral change is that it can finish the same task in fewer turns. Zeta Labs measured fewer turns and tool calls per task than Opus 5, at nearly half the cost, while completing twice as many of their hardest tasks.
Not every task benefits. Addy's cost analysis published alongside the release is blunt about it: on a well-scoped task, both models finish in about the same number of turns, and the price cut is all you get. The gap shows up on open-ended work, where a model can burn ten turns on the wrong approach before course-correcting. Fewer misdirected turns beat a cheap token every time.
Here's the pricing delta, indexed to Opus 5:
Those are per-token prices. The per-task number depends on your codebase, and the guidance from the release is to measure it, not assume. Short mechanical tasks won't see the turn-count win. Big open-ended refactors will, and that's where the savings compound.
Quick Take: The token bill was never the real cost; the attention the output demands, from the model's context budget to the human parsing it, is what decides whether agents actually pay off.
The verbosity tax nobody bills
The Reddit post that made the rounds this week was satire, mostly. Agents that narrate every decision, annotate what's load-bearing, and send a wall of text every time they report back. The author's solution was to stop reading the responses entirely and keep issuing commands.
It's a joke, but the underlying discovery is real. I found myself doing the same thing without deciding to. My reading speed is the bottleneck, not the model. A model that generates 30% faster doesn't help if I spend five minutes reading a status report that should have been three lines. I tried appending "tldr" to every prompt, then "caveman mode," and both got old. The preamble itself burns context, which Opus 5.5's pricing says is now the expensive thing.
The worse failure mode is over-capability, not verbosity. Give an agent that can act in the world a two-second glance task, and it will open a browser, screenshot the page, type a URL, take another screenshot, move the cursor, click, repeat. I watched exactly this happen this week on a "check the final draft alignment" request. It burned a chain of actions and tokens on something that needed about two seconds of looking. More capability didn't help. It just made the mistake more expensive.
That's the real routing lesson: match the shape of the tool to the shape of the task. Which is what everyone is doing anyway, whether they admit it or not.
Model routing: everyone has a hierarchy now
I never consciously decided which AI gets which job. I kept reaching for the tool that annoyed me the least for each kind of task, until one day I noticed I had an implicit ranking I couldn't explain.
Mine looks like this. Hard planning work and UI bugs with no obvious cause go to Opus inside Antigravity. Routine changes go to Gemini 3.1 Pro, which has more usage headroom. I know it hallucinates more in that context. I use it anyway for most of the day, because I can afford to run it more often. The model doing the bulk of my coding isn't the one I trust most. It's the one I trust enough.
Outside the IDE the routing gets stranger. ChatGPT handles the "is this even possible" checks because it answers in ten seconds. Claude gets quick drafts and urgent doc edits. Gemini has one non-negotiable lane: calculation-heavy problems. I have never once seen it give a wrong answer there, but I wouldn't trust it for general facts. That's a narrow trust that doesn't transfer.
The community is converging on the same pattern from different directions. Treat agent-written code like junior developer code: useful, sometimes impressive, never exempt from review. I now ask myself whether I'd merge a diff if a person had written it, and I've started treating the guardrails around agents with the same suspicion. I wrote a hook to block a dangerous tool call and assumed it held. The tool ran anyway. The hook was skipped in 574 milliseconds, and a hook that throws is not a block.
The framing that ties it together is risk-based routing. A quick formatting task and a production-facing architectural change shouldn't get the same reasoning, verification, or tool access. The question isn't which model is smartest. It's what the cost of being wrong is. Low-risk tasks go to fast, cheap models. High-stakes work gets the strong model plus human review. Anthropic built the same idea into its agent tooling as explicit model tiers.
Portable agents: one source, seven harnesses
The trending repo makes that tiered thinking concrete. wshobson/agents ships 94 plugins, 202 agents, 183 skills, 105 commands, and 16 orchestrators from a single Markdown source to seven harnesses: Claude Code, Codex CLI, Cursor, OpenCode, Antigravity CLI, GitHub Copilot, and Pi.
| Component | Count | What it is |
|---|---|---|
| Plugins | 94 | Granular, single-purpose installable units |
| Agents | 202 | Domain experts for architecture, languages, infra, security, data, ML, docs, business, SEO |
| Skills | 183 | Knowledge packages loaded on activation, not all at once |
| Commands | 105 | Slash commands for scaffolding, security scans, test generation, infra setup |
| Orchestrators | 16 | Multi-agent workflows for full-stack, security, ML, incident response |
The design constraint is what makes it interesting. Each harness gets idiomatic native artifacts, not lowest-common-denominator translations. Claude Code is the source of truth. Generator adapters emit a marketplace for Codex, a thin marketplace plus curated rules for Cursor, self-contained per-plugin trees for Antigravity, and command-as-skill conversions for Copilot. The 8 KB Codex skill cap is respected, permissions are handled per harness, and the generator owns only specific subdirectories so your own files elsewhere are left alone.
The tiered model strategy is the routing conversation made concrete:
| Tier | Model | Use |
|---|---|---|
| 0 | Fable 5 | Longest-horizon autonomous work, multi-hour runs, opt-in |
| 1 | Opus | Architecture, security, code review, production-critical work |
| 2 | inherit | User-chosen default for general work |
| 3 | Sonnet | Docs, testing, debugging, API references |
| 4 | Haiku | Fast operational tasks, SEO, deployment, content |
One source, multiple targets, explicit cost tiers. If you maintain agent tooling for a team, this is the pattern to copy: write it once, emit native artifacts per harness, and map model tiers to task risk. Plugins stay isolated, and installing one loads only its components into context, not the whole marketplace.
The model that runs the code is becoming the easy part. The human piece is not.
The ownership problem
The post that keeps getting shared this week is about the part of agentic coding nobody prices: responsibility. Developers write less of the code while becoming responsible for more of it. When production breaks at 2 AM, nobody asks which model generated the function. They ask who owns the system.
The old workflow had the developer touching almost every stage: understand, design, write, test, review, deploy, maintain. The new workflow inserts the agent at nearly every step, and the human shows up mostly at the start and the end. That creates a strange position: owning architecture you didn't design, code you didn't write, tests you didn't write, and edge cases you never considered.
The most dangerous failure is when the same model writes both the implementation and the tests.
Tests prove the code behaves according to an expectation. They can't prove the expectation was correct. When one model produced both sides, they share the same misunderstanding, and a green pipeline validates the shared error.
The term catching on for the follow-on problem is understanding debt. Technical debt is knowing the code is messy and shipping anyway. Understanding debt is owning code that nobody fully understands why it works this way. Messy code is visible. Missing understanding isn't. Everything looks fine until something unusual happens, and then nobody can answer why the system behaves that way, because the AI session is gone and the reasoning was never documented. I've caught myself reviewing a 15-file diff where my real understanding covered maybe six of those files. It passed CI. It probably passed code review too.
The mitigations are boring and they work. Ask for a plan before any code, and wait for approval. Fixing a bad plan is cheap. Fixing 800 generated lines that implement a bad plan is not. Keep tasks small so diffs stay comprehensible. Review decisions, not just syntax: not whether the line compiles, but whether this responsibility belongs in this module. Never merge code you can't explain: what changed, why, what can fail, and how to roll it back.
There's a harder question underneath, from the thread about what to build. The cost of building used to be a filter that killed bad ideas. That filter is gone. A working prototype that nobody needs still costs months of maintenance later, and the agent won't write that tail for you. The pre-build questions that matter now: what problem actually disappears, who has it, what happens if we don't build it, and would I build this if AI didn't make it easy.
Common pitfalls
Four mistakes show up repeatedly across these threads. All are avoidable.
Breaking your cache without noticing. Refresh a login mid-session, add instructions after the fact, or load a tool on demand and you've invalidated the expensive re-read context. The one-hour cache lifetime and mid-session effort changes only exist on newer models, and only if you don't kick the cache. Check /usage before optimizing anything else.
Trusting green CI when the same model wrote both sides. This is the shared-misunderstanding failure, and it's silent. Review at the requirement level before merging, and verify the agent's interpretation of the task independently of its tests.
Burning flagship models on trivial tasks. A two-second visual check does not need an agent that can open a browser and click around. Route by the cost of being wrong. Keep fast, cheap models for operational work and reserve the strong model for architecture, security, and production-critical reviews.
Loading your entire plugin catalog into context. Installing 94 plugins at once drags in agents and skills you never use, and every one of them is context your agent has to carry. Granular plugins with skills that load only on activation keep the prompt lean. If it isn't being read, it shouldn't be in the window.
One thing to remember: the agent session will disappear. The reasoning won't survive unless you write it down. Generating code gets cheaper every quarter. Owning software doesn't, and someone will own the system you merged.
The Bottom Line
If you're running long agentic sessions in production, engineer for cache reads. The one-hour lifetime, forked subagents inheriting the parent cache, and minimal mid-session changes are where the 60% cached-token cut actually lands. Your next savings come from turns avoided, not tokens discounted.
If you're building agent tooling for a team, copy the single-source multi-harness pattern. Maintain one Markdown source, emit native artifacts for whatever harness your developers actually use, and map model tiers to task risk. Maintaining one harness costs the same as maintaining one source, and you get the other six harnesses for the marginal cost of running a generator.
If you're adopting coding agents on a team, mandate plan-before-code and explain-before-merge. The models change quarterly and pricing keeps moving, but understanding debt compounds regardless of which model wrote the code. The developer who reviews the plan is the one who'll own the 2 AM incident.