What real runs actually look like
Rote's example workflows include anonymized observations from the production agents they were built from. The ops-report agent averaged about 17 turns and 0.9 million cache-read tokens per run. The deal-monitor agent averaged about 22 turns and 1.6 million cache-read tokens. The invoice-push example records two browser-driving runs of 184 and 730 turns, costing roughly $20 each. These describe the source agents before compilation. They are not post-compilation results and not a guarantee about your workflow, but they are a more honest starting point than a vendor average.
deal-monitor: ~22 turns, ~1.6M cache-read tokens per run
invoice-push browser runs: 184 and 730 turns, roughly $20 each
Observed source agents in the Rote examples, before compilation.
Why the context window is the expensive part
A 22-turn run that reads 1.6 million cached tokens is not reading 1.6 million distinct tokens. It is re-reading a growing window twenty-two times: the instructions, the tool schemas, the transcript so far, and the full body of every prior tool result. That is why cache-read counts dwarf what the task appears to involve, and why the cost of a run grows super-linearly with its length. Prompt caching makes the re-reading much cheaper, which is real and worth enabling, but it discounts the re-reading rather than removing it.
What independent research measured for compiled implementations
The Compiled AI paper (arXiv 2604.05150) compared agentic and deterministic implementations of the same work and reports 57 times fewer tokens at 1,000 transactions, 450 times lower median latency, 100% reproducibility for the deterministic implementation against 95% for direct inference at temperature 0, and roughly 40 times lower total cost of ownership at one million transactions per month. Anthropic separately documented an MCP code-execution example with a 98.7% token reduction, from 150,000 tokens to 2,000. Neither result is a Rote benchmark and neither is a promise about your workflow. They are evidence for the mechanism: removing inference from repeated work changes the shape of the cost curve rather than shifting it down a little.
arXiv 2604.05150: 450× lower median latency; ~40× lower TCO at 1M transactions/month
arXiv 2604.05150: 100% reproducibility vs 95% at temperature 0
Anthropic MCP code execution: 98.7% token reduction in one documented example
Independent of Rote. Not universal guarantees.
The conversation with finance
Finance will ask what this costs per employee, because headcount is the denominator they already have and it is how every other tool gets budgeted. The honest engineering answer is that automation cost does not track people, it tracks events: tickets filed, deals reviewed, invoices processed. A team of five automating a high-frequency process can outspend a team of fifty automating a rare one. Give them the per-employee figure for the budget line if they need it, then move the discussion to marginal cost per run, which is the number that actually responds to a decision.
What compilation changes about the marginal cost
An agent's marginal cost per run is close to its average cost, because every run repeats the full procedure. That is the property that makes the bill scale with volume. Compiling the settled steps into code moves most of that work into the fixed cost of building and reviewing the pipeline, leaving a marginal cost made up of the retained judgment nodes, the external calls, and the runtime. The remaining inference surface is visible in the emitted pipeline rather than implied, so the per-run figure can be estimated before rollout instead of discovered on an invoice.
How to build the case without inventing numbers
Pull the run count per month and the input and output tokens per run from your own logs rather than an estimate. Multiply by current model prices and record the date, because prices move and an undated figure is not auditable. Include retries, failed runs, and human rework, which naive models omit and which finance will find. Then run rote eval for an assumption-visible scorecard, and rote eval --run when the real tools and runtime are available to compare both implementations against the same cases. Publish the assumptions next to the conclusion so a reader can disagree with the inputs rather than the result.
Frequently asked questions
How much does it cost to run AI agents in production?
It depends almost entirely on turns per run, context carried per turn, and runs per month, so any single quoted figure is a guess. For calibration, production agents observed in Rote's examples ran about 17 to 22 turns with 0.9 to 1.6 million cache-read tokens per run, and two browser-driving runs of 184 and 730 turns cost roughly $20 each. Measure your own logs rather than adopting an industry average.
Why is my agent's context window so expensive?
Because every turn resends the accumulated context: instructions, tool schemas, the transcript so far, and the full body of prior tool results. A twenty-turn run therefore pays for a growing window twenty times over, which is why cache-read token counts are far larger than the task appears to warrant. Caching lowers the price of that re-reading; it does not reduce how often it happens.
How do I calculate ROI on AI automation?
Compare the fully loaded cost of the automated process against the cost of the work it replaces, using measured token counts and dated model prices rather than estimates. Include retries, failed runs, and the human rework the automation still generates, since these are usually what turns a positive model negative. State the assumptions alongside the number so the calculation can be challenged on its inputs.
When should I compile a skill?
Keep one-off exploration in an agent. Compile a skill after the procedure is proven, repeats often, and needs lower cost, faster execution, regression tests, explicit approvals, or reliable retries.
Compile a workflow
Inspect the open-source CLI or run a compilation in Rote Cloud.