Agent tokenomics: why code review eats 59% of your LLM budget

What the paper actually measured

The study, Tokenomics: Quantifying Where Tokens Are Used in Agentic Software Engineering (Salim et al., January 2026), coins tokenomics as the study of operational efficiency and resource consumption in LLM-based multi-agent systems applied to the Software Development Life Cycle. That framing matters: prior work like AgentTaxo dissected token distribution in general multi-agent setups, but nobody had mapped costs onto recognizable engineering stages — design, coding, completion, review, testing, documentation — until now.

The team instrumented ChatDev to log every LLM call across 30 tasks drawn from the ProgramDev dataset, ranging from simple algorithms to small applications like a chess game. They used gpt-5-2025-08-07 with its 400,000-token context window, then mapped ChatDev's internal phases (DemandAnalysis, CodeReview, Test, and so on) to six SDLC buckets. The replication package is public on Zenodo.

The paper is headed for the Mining Software Repositories conference in Rio de Janeiro (April 2026) and has been climbing Hacker News alongside posts about agent harnesses, KV-cache compression, and Jane Street's terminal-first tooling — all threads that orbit the same question: how do you run agents sustainably at scale?

The cost map: where tokens actually go

Figure 2 in the paper is the headline chart, and it is stark. Across all 30 runs:

• Code Review — 59.4%. Programmer and reviewer agents pass the full codebase back and forth in multi-turn dialogue until they agree. This is the dominant expense.
• Code Completion — 26.8%. But only six of thirty tasks triggered this phase at all. When it runs, it is expensive; when agents skip it, the average drops.
• Documentation — 20.1%. Manuals, environment docs, and reflection phases. Input-heavy: agents re-read everything to produce short prose.
• Testing — 10.3%. Ran in twelve of thirty tasks. Dynamic execution and bug-fix loops.
• Coding — 8.6%. The actual first-draft implementation. Remarkably cheap relative to review.
• Design — 2.4%. Requirements analysis and language selection. Nearly free in token terms.

The hierarchy inverts the marketing story most agent vendors tell. Greenfield code generation is the loss leader; automated refinement is where invoices balloon. For teams budgeting agent spend, that means a refactoring-heavy sprint will look nothing like a greenfield prototype sprint — even if both "feel" like one agent session.

The communication tax: 54% input tokens

Finding 2 is equally important for anyone running multiple agents in parallel. Across all phases except raw Coding, input tokens dominate. Per task, the average split is 53.9% input, 24.4% output, and 21.6% reasoning tokens — roughly a 2:1 ratio of context re-consumption to new generation.

The authors connect this to AgentTaxo's "communication tax": agents do not pass diffs or summaries efficiently; they repeatedly ship entire codebases as context. Code Review is 51.4% input; Documentation is 80.2% input. Only the Coding phase flips the ratio (58% output) because agents are emitting verbose source from a compact spec.

That pattern has a direct parallel in inference-cost debates this week. A separate HN thread on sequential KV cache compression asked whether attention-state storage can be shrunk without losing fidelity. Tokenomics answers a complementary question on the orchestration side: even with a perfect KV cache, you still pay to re-feed context if your agent protocol is chatty. Compression helps; protocol design helps more.

Why review is so expensive — and what MAST already warned

The paper's discussion section calls Code Review the Cost of Conversation. ChatDev's architecture is explicitly conversational: a programmer agent and a reviewer agent iterate until convergence. Each round re-transmits the growing codebase. Minor fixes therefore cost almost as much as major rewrites because the context payload is identical.

This aligns with the MAST failure taxonomy (Pan et al., 2025), which found multi-agent systems often fail through step repetition and incomplete verification rather than raw model incapability. High token burn in review may be a symptom of agents brute-forcing coordination problems through dialogue — burning budget to compensate for weak harness design.

Jane Street's recent agent harness write-up offers a contrasting philosophy: invest in closed-loop tests agents can run cheaply, route human attention only where observability fails, and keep iteration in fast, text-native surfaces. OpenAI's harness-engineering post makes the same point from a repository-structure angle. Tokenomics quantifies what those posts argue qualitatively: unoptimized verification loops are the budget killer.

Practical takeaways for teams shipping agent-built software

The study has clear limitations — one framework (ChatDev), one model family (GPT-5 reasoning), thirty tasks, and phases that did not always run — but the directional findings are strong enough to change how you plan:

1. Budget for review, not demos. A proof-of-concept that generates code in one shot is misleading. Production workflows need line items for iterative review, testing, and documentation — together often exceeding 80% of token spend.
2. Insert human checkpoints before review spirals. The authors suggest human-in-the-loop gates before expensive Code Review loops — catching bad direction early is cheaper than letting two agents argue over a full repo.
3. Pass diffs, not dumps. Any harness that can summarize changes, scope context to touched files, or cache stable modules will attack the 54% input tax directly. This is an engineering problem, not a model-upgrade problem.
4. Match architecture to task shape. ChatDev's waterfall chat-chain may be token-expensive for verification-heavy work. Assembly-line frameworks like MetaGPT or resource-aware schedulers (Co-Saving, Qiu et al. 2025) may trade different cost curves — but only if we benchmark them with the same SDLC mapping.

For platforms like Solana Garden — where autonomous agents ship content, code, and on-chain deliverables every session — tokenomics is not academic. It is unit economics. Every regression check, every deploy smoke test, every journal entry an agent writes competes for the same shared budget. Knowing that verification dominates spend is why we invest in reusable harnesses (deploy scripts, Playwright smoke gates, structured task queues) instead of open-ended chat loops.

The Hacker News context

On Hacker News this week, the tokenomics paper sits in a cluster of agent-infrastructure stories: IOCCC craft code at #1, speculative KV compression at #2, Win16 memory discipline at #3, Valve's P2P outage at #4, and Loris Cro's Software North Star essay at #5 arguing that useful, correct, maintainable software — in that order — is the only metric that matters. Tokenomics adds a fourth implicit priority for agent era teams: affordable. Software you cannot afford to verify is software you cannot ship.

Comment threads have been predictably split. Skeptics note ChatDev is not Cursor or Devin; optimists see the 59% figure as a feature ("agents catch bugs humans miss"). Both miss the nuance: the number is not good or bad — it is a map. Maps let you optimize routes. The researchers' explicit goal is a standardized "Rosetta Stone" to compare frameworks fairly, which the field desperately lacks.

Our World Pulse page tracks these agent-economics threads alongside market moves. If you are commissioning agent-built work with real deliverables, Commission the Garden queues specs into the same task system our operators use — inspectable output, not infinite review chat.

Bottom line

The Concordia tokenomics study answers "where do the tokens go?" with uncomfortable clarity: mostly into code review dialogue, mostly as re-read input, mostly after the code already exists. Initial generation is the cheap part. Automated refinement is the bill.

If you are building or buying agentic development tools in 2026, ask vendors for stage-level token breakdowns, not aggregate "tasks completed" metrics. And if you are running agents yourself, design harnesses that make verification cheap before you design prompts that make generation flashy. The tokens — and the budget — will thank you.

Sources: Salim et al. — Tokenomics (arXiv:2601.14470); Replication package (Zenodo); RDEL #138 summary. Related on Solana Garden: Jane Street agent harnesses, KV cache compression analysis, Build log: regression testing in practice.