The surprising thing about an agentic coding bill is not the rate. It is that the rate looks small, the task looks small, and the invoice does not.
Four things drive that, and only one of them is the price per million tokens.
Your context is re-sent every turn
A chat is one request. An agent doing one task is a loop, and each pass through it re-sends the accumulated conversation: the system prompt, the files it has read, the diffs it has proposed, the tool results it got back, and everything it said in between.
Turn twelve is not a twelfth of the work. It carries the whole of turns one through eleven as input. A task that touches six files and runs twenty turns can send those six files twenty times, and input tokens are the cheap ones only in the sense that there are a great many more of them.
This is why "make the model smaller" often does not help as much as expected and "make the task narrower" does. Halving the price per token halves the bill. Halving the number of turns halves the bill and halves the context each remaining turn carries.
Prompt caching moves the cost rather than removing it
Every serious provider now offers a cache: send the same prefix twice and the second read is heavily discounted. Good. It is also three prices instead of one — a cache write, a cache read, and the ordinary uncached input rate — and the write typically costs more than plain input.
So an agent that reorders its context between turns, or that appends something near the front, pays the write price repeatedly and gets the read discount never. The behaviour looks identical from the outside. The bill does not.
Codoro's catalogue carries all four numbers per model — input, output, cached input, cache write — because a table with one input price cannot express this, and a table that cannot express it will be used to make a decision that is wrong.
The rate you looked up may not be the rate you pay
This is the part I would not have predicted before building the billing path.
A model's published price is frequently not a single number. The same model can carry a different rate in the US and the EU. Some models price by whichever provider endpoint serves the request. Some have tiered long-context rates where crossing an input threshold reprices the entire request, not the excess above the threshold.
And the choice of region and endpoint is not ours. The gateway decides, after we have sent the request.
That creates a genuine problem for anything that wants to stop a run before it overspends: you have to commit to a number before the thing that determines the number has happened.
Reserving and settling are different operations
The way out is to hold and settle at two different prices, and to be explicit that they are different.
The hold is taken before the first token, at the dearest price the request could possibly attract
— maximised across regional variants and, where a model prices per provider, across whichever
endpoints are currently up. In Codoro's catalogue that is a separate field, reserveRates, present
only when it differs from the headline price, which for most models it does not.
The settlement is the vendor's actual published rate for what actually happened.
Both errors here are real and they are not symmetric. Reserving at the headline price under-reserves, and under-reserving defeats the entire purpose of a cap — the reservation is the thing that stops a run. But settling at the dearest price would charge every developer a regional premium their request may never have attracted, and that one shows up on an invoice where they can see it.
A hold is not a charge. Conflating them is the most expensive small mistake available in this codebase, and keeping them apart is why the catalogue has two rate tables.
Caps, and where they actually bind
Three numbers, and the useful one is the first:
| Cap | Default | Who sets it |
|---|---|---|
| Per run | $2.00 | The developer, per task |
| Per developer per day | $25.00 | The team owner |
| Markup on your own API key | 0% | Not applicable |
The per-run cap is the one that changes behaviour, because it binds while you are still in the room. A daily cap tells you about a bad afternoon after the afternoon. A run cap interrupts the specific task that is going wrong, which is the moment the information is worth something.
When a run hits its cap it pauses and offers a cheaper model. It does not silently downgrade, and that is deliberate: a run that quietly switched models mid-task would produce a diff you would review under assumptions that stopped being true partway through.
Your own key, or ours
Two ways to pay, and the difference is straightforward.
Bring your own key and the markup is zero. The provider bills you directly, the key is stored in the macOS keychain, and it is transmitted only to the vendor that issued it. Codoro takes nothing on the tokens. You get the caps, the catalogue, and the model switching; the provider gets the money.
Use hosted credits and the default markup is 40% on cost, with published per-model overrides. Worth being blunt about what that pays for: after Stripe's 2.9% plus 30 cents, a 40% markup on cost nets something in the region of 25% of revenue. That is the margin on the convenience of one bill and no key management.
If you already have provider accounts, bring the keys. The zero-markup path is not a loss-leader with a catch; it is the honest price of a product whose value is the interface rather than the tokens.
What to actually change
In rough order of how much it saves:
- Cut turns, not models. Give the agent a narrower task. A twenty-turn task decomposed into two eight-turn tasks costs less than half, because the context each turn carries also shrinks.
- Watch the cache write rate, not just the input rate, on any model you use heavily.
- Set a per-run cap you would actually be annoyed to hit. A cap set above your worst case is decoration.
- Check whether your model has a long-context tier, and where it starts. Crossing it reprices the whole request, so a task sitting just under the threshold is meaningfully cheaper than one just over.
- Bring your own key if you have one.
Where Codoro is
There is no public download. The macOS build is in preview, the download page is a waitlist until a signed release manifest says otherwise, and the pricing above describes the launch model rather than a checkout you can reach today.
The catalogue is real, though — roughly 216 models synced from Vercel AI Gateway, with a CI check that fails when our committed rates drift from the published ones. Prices in this article come from that table rather than from a vendor's marketing page, which is the only reason I am willing to put numbers in an article that will still be here in a year.