Blog · 2026-07-21 · Vynaris Team

Token optimization: the break-even math for when it is not worth the engineer time

Token optimizations save a similar amount per call, $0.009 to $0.016 on a Haiku-class call, prices verified 2026-07-21. What varies 20x is the engineer time to build them, so labor sets the break-even. Below ~3,700 calls a month, most never pay for themselves.

A token-optimization project saves roughly the same amount per call whether you trim prompts, add caching, or route to a cheaper model: between $0.009 and $0.016 on a typical Haiku-class call, prices verified 2026-07-21. What differs by 20x is the engineer time to build it. So the break-even is set by labor, not by the token delta, and below a few thousand calls a month most of these projects never pay for themselves. Here is the arithmetic, per optimization, that you can re-run with your own volume.

The finding, before the math

Engineers reach for token optimization as if it is always free money. It is not. Every optimization has a fixed build cost in hours and a per-call payoff in fractions of a cent, and the ratio of those two numbers decides whether the work clears its own cost. The uncomfortable result: the three most common optimizations save almost the same per call, so the one that pays back first is simply the one that took the fewest hours to ship. A managed-gateway config change and a hand-rolled router service can deliver the identical saving while their break-even volumes differ by 32x.

We built this from public prices only. No product data. Every hour estimate and token count below is an assumption you can edit; every price is from a provider's live page, captured 2026-07-21.

The method: cost of the fix versus savings per call

The rule is one line. An optimization is worth doing when the money it saves over the amortization window exceeds what it costs to build and maintain over that same window.

We price each project two ways. First-month break-even asks how many calls it takes to pay back the entire build in the first month, the number a skeptical finance lead will ask for. Amortized break-even spreads the one-time build over six months and adds any ongoing maintenance, the number that reflects a system you will actually run. Both use a loaded engineer cost of $100 per hour, an editable assumption; use $75 to $150 for your team.

The three optimizations we model, each on the same Claude Haiku 4.5 call unless noted:

• Prompt trimming. Cut a bloated system prompt and few-shot block from about 20,000 input tokens down to 4,000, saving 16,000 input tokens on every call. At $1.00 per million input tokens that is $0.016 saved per call. Build: about 4 hours to read the prompts, cut safely, and re-test for regressions.
• Model routing. Right-size a 2,000-in / 500-out call from Claude Opus 4.8 at $0.0225 down to Haiku 4.5 at $0.0045, when the task is simple enough. Assume half your traffic is routable, for an effective saving of $0.009 per call. Build depends entirely on how you ship it: a config change on a managed gateway, or a service you own.
• Prompt caching. Cache a 10,000-token stable prefix so its input reads at 0.1x instead of full rate, saving $0.009 per call once the prefix is reused. Build: about 2 hours to mark the cache breakpoint and confirm hit rates.

The per-call savings live in a narrow band, $0.009 to $0.016, a 1.8x spread. Hold that thought, because the build costs do not.

The break-even table

Same $100 per engineer-hour, same six-month amortization, four ways to ship. The cost-per-token savings are computed from the 2026-07-21 prices above; the build hours are the editable input.

Optimization                  Saved / call  Build cost        Break-even / mo
----------------------------  ------------  ----------------  ---------------
Routing (managed gateway)     $0.0090       $200              3,704
Prompt caching                $0.0090       $200              3,704
Prompt trimming               $0.0160       $400              4,167
Routing (DIY router service)  $0.0090       $4,000 + $400/mo  118,519

Read the top three rows and the meta-lesson jumps out. Prompt trimming saves 1.8x more per call than caching, yet its break-even is slightly higher, because it took twice the hours to build. The saving barely moves the break-even; the labor sets it. Then read the fourth row. The DIY router saves the exact same $0.009 per call as the managed gateway, but building and maintaining your own routing service breaks even at 118,519 calls a month against the gateway's 3,704, a 32x gap driven entirely by the $4,000 build and $400-a-month upkeep. Same saving, same tokens, 32x difference in when it pays off.

Why the token delta barely matters

The instinct is to chase the biggest per-call saving. The table says that instinct is wrong at low volume. Per-call savings across these techniques cluster within 1.8x, while build cost varies 20x, from a $200 config edit to a $4,000 service. Multiply a saving that lives in a 1.8x band against a cost that lives in a 20x band and the cost term wins every time. The optimization that pays back first is the cheapest to build, not the one with the fattest token delta.

This is the same trap we documented in the router savings audit, where headline "70% savings" claims collapsed once the engineering and maintenance cost of the router was counted against them. It is also why the managed gateway versus DIY total-cost comparison lands where it does: the per-request price of routing is a rounding error next to the salary of the person maintaining the router. The token bill is not the total cost of a token optimization. The engineer is.

Model routing itself is genuinely worth doing, when the routing decision is reliable, which is a separate question we cover in could a cheaper model handle this. The point here is narrower: how you ship the router, config versus custom code, decides the break-even far more than the model routing saving does.

The don't-bother line

Below about 3,704 calls a month, even the cheapest project in the table, a managed-gateway routing rule, does not clear its own six-month cost. Everything more expensive to build needs even more volume. So the honest default for a low-traffic service is: pay the bill. A team running 1,000 calls a month against Haiku is spending single-digit dollars; a $200 optimization to shave 20% of that is four months of the engineer's time to recover pennies. Run your own numbers through the calculator before you spend an afternoon on it.

Where the line moves: raise your call volume, your per-call token count, or your engineer's effective rate, and cheap optimizations cross into worth-it fast. A caching change that breaks even at 3,704 calls a month is obvious at 50,000 and mandatory at 500,000. The break-even is a threshold, not a verdict; the mistake is optimizing below it out of habit.

When it is worth it, and when it is not

The honest tradeoff cuts both ways, and the deciding variable is volume, not virtue.

Do the cheap, config-level work as soon as you are past a few thousand calls a month. Prompt trimming, a managed-gateway routing rule, and prompt caching all break even in the low thousands of calls and take an afternoon; at real production volume they are free money you are leaving on the table. Trimming also cuts latency and context bloat, so it earns its keep beyond the token line, a point we quantified in the scaffolding token-overhead post.

Do not build the expensive, custom version until the volume demands it. A DIY router service breaks even at roughly 118,519 calls a month; below that, a managed gateway delivers the identical saving for 32x less build cost. Writing your own router at 10,000 calls a month is over-engineering with extra steps, and you inherit the maintenance forever. And do not optimize at all below the don't-bother line: at 1,000 calls a month the entire monthly bill is smaller than one hour of the engineer you would assign to shrink it.

The recursive version of this mistake is real. One engineer on Hacker News described burning an entire token budget researching how to save tokens; the meta-cost of the optimization exceeded the thing being optimized. Measure the bill first. If the number is small, the correct optimization is to spend zero hours on it.

FAQ

When is token optimization not worth it? Below the break-even call volume for the specific fix. On this model a managed-gateway routing rule or a caching change breaks even near 3,704 calls a month at $100 per engineer-hour; below that, the build cost never clears. Prompt trimming breaks even near 4,167 a month. A DIY router service needs about 118,519 a month. Compute your own from monthly volume times per-call saving versus build hours.

Why do different optimizations have such different break-even points if they save the same amount? Because the break-even is set by labor, not tokens. Per-call savings here span only 1.8x ($0.009 to $0.016), but build cost spans 20x ($200 to $4,000), so the cheaper-to-build fix pays back first even when it saves less per call. A managed gateway and a DIY router save the identical $0.009 per call yet break even 32x apart.

Should I build my own router or use a gateway? At the volumes most teams run, use the gateway. The output-token and input savings are identical either way, but the DIY build costs $4,000 plus $400 a month to maintain versus about $200 for a config change, moving break-even from 3,704 to 118,519 calls a month. Build your own only past six figures of monthly calls or when you need routing logic no gateway offers.

Does prompt caching always pay off? Only when the prefix is genuinely reused and you are above the break-even. Caching a 10,000-token prefix saves $0.009 per cache-hit call and breaks even near 3,704 calls a month here. If your prefix changes every call, or your volume is below the line, the 1.25x cache-write surcharge can cost more than it saves. We covered the provider-by-provider write policies in prompt caching in production.

What engineer rate should I use? We use $100 per hour loaded, an editable assumption. At $75 an hour every break-even drops about 25%; at $150 it rises 50%. The rate scales the build cost linearly, so it moves the break-even volume by the same factor. Plug in your team's real loaded rate.

Sources

• Anthropic pricing (Haiku 4.5 input $1.00 and output $5.00 per MTok, Opus 4.8 $5.00 and $25.00, cache read 0.1x, cache write 1.25x), captured 2026-07-21: https://platform.claude.com/docs/en/about-claude/pricing
• The recursive optimization trap: "I burned all my tokens researching how to save tokens," Hacker News 171/207: https://news.ycombinator.com/item?id=48967355
• Fixed scaffolding overhead in practice: "33k tokens of system prompt," Hacker News 705/396: https://news.ycombinator.com/item?id=48883275
• Break-even model script and all per-call arithmetic: from the assumptions above, run reproducibly.

Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers here are current as of 2026-07-21.

The lesson from the math: a token optimization is an engineering project, and like any project it has a break-even. Below it, the correct move is to pay the bill and spend the hours elsewhere. Vynaris is an OpenAI-compatible gateway that gives you routing, caching, and per-call cost visibility as a config change instead of a build, so the cheap optimizations stay cheap. One base URL swap. Get an API key at vynaris.com.