A 50-developer team shipping at an agentic pace will spend roughly $900,000 this year on AI and developer tooling costs. Most of the engineering leaders I’ve talked to saw the compute costs coming. What they didn’t anticipate was where the rest of the bill was hiding.
The culprit is a timing problem. Frontier models price context reads on a sliding scale, and standard validation pipelines take longer than the discount window allows. By the time a failure comes back, the agent re-reads the full codebase at full price, carrying the previous attempt’s output plus build logs. Each retry costs more than the last.
The teams getting ahead of this are moving validation earlier, into the agent’s working environment, so failures get caught while that cache is still warm.
Understanding what’s driving the bill requires a different kind of measurement. The metrics most teams use to gauge delivery health were designed around the same assumption as the tools themselves: that a developer is driving the work. DORA metrics like deployment frequency and change failure rate are useful signals, but they weren’t built to account for what happens when agents are driving the volume. They tell you how fast you’re moving, not what each step costs.
That’s what led us to focus on cost per shipped change (CPSC): the total CI and AI token spend required to get one change from development to production, including all feature branch tries and retries, and the final merge to main. CPSC captures something that per-seat AI pricing and compute invoices don’t show on their own. It reveals the full economic weight of every cycle required to ship.
The operational picture makes clear why this metric matters: teams are generating more code than ever but struggling to get it into production. The most recent State of Software Delivery Pulse Report puts it plainly: main branch success rates stand at 76.7%, meaning nearly one in four attempts to merge code into production fails. When builds do fail, the median team takes well over an hour to recover. You can explore the data yourself to see how these trends are playing out across industries, team sizes, and regions.
The gap between high performers and everyone else is striking. Looking at an anonymized cohort of the 20 organizations with the highest main-branch throughput on CircleCI, we found that the top teams cut their CI compute spend per shipped change by 31% year over year. The median team moved the other way, with CI credit usage per shipped change rising 13% over the same period. The difference traces directly to a metric we call Merge Efficiency Ratio (MER): the number of feature-branch validation cycles required before a change lands on main. The top teams ran far fewer of them.
Here is what the economics look like when you account for AI token costs as well. Take a 50-developer team shipping roughly 3,000 changes per month. At the typical MER, each shipped change requires about five total CI runs, four on feature branches and one on main. For each change, our cost model puts the bill at roughly $13 in input tokens from cold cache reloads and context bloat, $9 in output tokens from agents rewriting code after CI failures, and $3 in CI compute. That comes to approximately $25 per shipped change. Across 3,000 changes, that’s $75,000 per month, or $900,000 per year. Actual costs will vary by model, context size, cache behavior, and retry rate, but the pattern holds: at AI-driven volume, slow feedback loops consume a meaningful share of the delivery budget. For larger codebases requiring 500K input tokens or more, the same pattern crosses $1.5 million.
The expensive part is not catching failures. It is catching them too late.
The teams getting ahead of this have found ways to validate in the inner loop, before the push, so CI handles the work it was actually built for: reproducible environments, integration tests, the final gate before code ships. Tools like Chunk sidecars are built for this. They run a distilled set of checks inside the agent’s environment in under 30 seconds, catching failures while the context cache is warm and the fix is cheap. In our testing, microbuild output was about 5x more token-efficient than standard CI logs, because it returns focused failure context rather than full pipeline output.
Teams that close this gap aren’t just reducing their bills today. They are building delivery infrastructure that holds as the pace of agentic development continues to grow.