A new empirical study running 30 agentic software development tasks through a multi-agent framework on GPT-5 found something that should change how every engineering-led organization thinks about its AI budget:
The paper is "Tokenomics: Quantifying Where Tokens Are Used in Agentic Software Engineering" (arXiv 2601.14470). It landed on Hacker News at #8 with 114 points and 47 comments — and the practitioner response in the thread is striking: developers corroborating the numbers from their own production logs.
One HN comment: "I'm seeing a ratio of around 10:1 in my usage. A vast majority of the tokens consumed are on the input side. The agent will often read a million tokens just to patch one line of code."
Another, immediately below: "If input tokens dominate the cost to that extent, this implies that major gains are possible by making better use of caching."
The Hacker News thread is an informal, self-selected survey of developers who actually run agentic AI in production. The agreement is near-universal. This isn't a theoretical paper. It's empirical validation from the field.
The finding that Code Review = 59.4% of token spend flips a common assumption. Most organizations optimize their AI spend by negotiating output token discounts — the visible line item, the number in the API bill. But the real cost is in the input side:
These are input token events. They dominate 53.9% of the total bill. Output tokens — the generated code, the review comments, the test output — are the minority of spend.
The 10:1 ratio a commenter reported isn't an edge case. It's the structural reality of agentic code review at production depth. Here's the arithmetic at GPT-5 pricing:
At 5 review iterations per PR (conservative for a complex change), that's $20 in input tokens for $0.03 in output — before any generation, test runs, or debug loops. The review loop is expensive not because it's complex, but because it reloads context at full price on every pass.
Input token cost has one clean optimization path: reduce the number of tokens in the input without reducing the information density. This is what lossless compression does at the prompt layer.
Consider the difference between lossy and lossless approaches:
For code review specifically, the redundancy lives in:
Lossless proxy-layer compression targets these redundancies at every request. The model gets a semantically equivalent but token-reduced input. The output is unchanged. The cost per request drops by 30–40% on typical agentic workloads.
If you don't have per-workflow cost visibility today, the paper is your justification to get it. The difference between "we spent $2M on AI this month" and "59.4% of our $2M was on code review loops, and we can reduce that by 35% with compression" is the difference between a line item and a budget decision.
Three actions for FinOps teams reading this:
Not all API calls are equal. A call that re-reads a 500k-token codebase on a review iteration is a different cost event than a call that generates a 50-token function. If your gateway logs don't capture this distinction, add it. You cannot optimize what you can't see.
The Tokenomics paper found 53.9% input. Your production ratio is probably different — but unless you've measured it, you don't know. Track it weekly. The ratio is the leading indicator for where your next dollar of optimization goes.
The paper's finding is specific: input tokens dominate. Compression attacks input tokens directly. The ROI calculation is straightforward — 30–40% reduction on the dominant cost category, no quality degradation, additive to routing and caching. It's not a nice-to-have. It's the first lever on the largest cost pool.
The paper's findings are not an argument against AI code review. They're an argument for running it efficiently. A 10:1 input:output ratio is not a sign that the process is broken — it's a sign that the context reloading is expensive and addressable.
The companies that get this right will run the same agentic review loops at 40% lower token cost. Their models see the same code. Their engineers get the same feedback. Their bills are lower. This is not a tradeoff — it's an engineering problem with a clean solution.
The Tokenomics paper is the most useful piece of third-party validation the AI FinOps space has produced this year. It gives engineering and finance a shared empirical anchor: input token mass in iterative review loops is the dominant cost driver in agentic software development.
That's not an opinion. That's a measurement across 30 standardized tasks on a production-scale framework. It's reproducible, it's specific, and it has 47 HN comments from developers who looked at their own logs and said "yes, that's what we see."
The first-principles response: compress the input side. Losslessly. At the proxy layer. On every request. That's what Trimio's CCR stack was designed for — and the paper just gave you the benchmark to measure whether it's working.
Trimio's lossless compression engine targets input token mass at the proxy layer — the exact cost driver the Tokenomics paper identified. See the architecture.