Guides / poc to production cost
Why the pilot said it was cheap and production disagreed
A proof of concept measures cost per call under conditions production never repeats: short conversations, no retries, no tail users. Multiplying that figure by real volume under-forecasts, often badly. Culpa, a local-first LLM cost, margin, and forecast ledger, prices your real traffic so the forecast comes from production rather than from a demo.
Why this happens
The pilot works, the bill is trivial, and somebody divides it by the request count to get a cost per call. That number then gets multiplied by the production forecast, and it's the one input in the whole exercise that doesn't hold. A demo runs short conversations, because nobody demos a forty-turn session. It has no retry rate, because it ran on a good afternoon. It has no tail of heavy users, because it had six users and they were all colleagues. Each of those pushes real cost per call up, and they compound rather than average out. There's a second, opposite effect that confuses the argument: some savings only become available at scale. Caching a large system prompt loses money on a pilot and pays handsomely in production, so the pilot is simultaneously over-optimistic about volume-driven cost and over-pessimistic about what optimisation can recover. The only way through is to measure the shape rather than the total, which means knowing your real conversation lengths, retry rate and usage distribution before committing to a number.
What this usually looks like
- Your production forecast is the pilot's cost per call times expected volume.
- The pilot ran conversations far shorter than real ones.
- Nobody knows your retry rate because the pilot never hit one.
- Cost per call has risen every month since launch and nobody expected it to move.
- The business case was signed off on a number measured over a few hundred requests.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Mistakes that cost the most
| Mistake | Why it hurts | Do instead |
|---|---|---|
| Extrapolating the pilot's cost per call. | It's the one figure the pilot measures least reliably, and it moves upward with scale. | Forecast from the shape: conversation length, retry rate and the usage distribution. |
| Demoing short conversations. | Input grows with turn number, so real sessions cost more per call than demo ones. | Run the pilot at realistic conversation lengths, even if it's slower to demo. |
| Assuming usage is evenly distributed. | A small tail of heavy users can dominate the bill, and a pilot rarely contains one. | Model a skewed distribution explicitly, and price the top decile separately. |
| Writing off caching because the pilot showed no benefit. | A cache write costs more than base input, so caching genuinely loses money at pilot volumes. | Re-test caching at production call rates rather than concluding from the pilot. |
Run this check tonight
- Compare your pilot's average conversation length to a real session today.
- Find your actual retry rate, and check whether the pilot's forecast included one.
- Look at usage by user and see how much of it your top decile accounts for.
- Re-run the caching decision at production call volume rather than pilot volume.
The pilot's figure against the production one
Illustrative example
A modelled pilot at 3,000 input and 500 output tokens per call on Claude Sonnet 5, at its real introductory rates of $2.00 and $10.00 per million from the price book effective 2026-07-02. Production runs the same feature at 6,000 input, because conversations accumulate history, with a 15% retry rate. Volume is 5,000,000 calls a month. Rates are published, every volume and shape below is modelled.
Nothing in that gap is a price change or a mistake in the arithmetic. The pilot measured a real cost per call for the conditions it ran under, and production ran under different ones. The forecast was wrong the moment it treated a measurement as a constant.
Every number, with its confidence and source
| Figure | What it means | Confidence | Source |
|---|---|---|---|
| $97,750.00 against $55,000.00 | modelled monthly cost at production shape against the same volume forecast from a pilot's cost per call | calculated | A modelled 3,000 input and 500 output tokens per call on Claude Sonnet 5 at real introductory rates of $2.00 and $10.00 per million from the price book effective 2026-07-02 gives $0.0110, so 5,000,000 calls forecasts $55,000.00. At a modelled production shape of 6,000 input, the same 500 output and a 15% retry rate, per-call cost is $0.0170 x 1.15 = $0.01955, so the same volume costs $97,750.00, which is $42,750.00 and 78% higher. Rates are published, every volume and shape is modelled. |
What a generic answer can’t know
Conversation length, retry rate and the shape of your usage distribution are all properties of your own traffic, and none of them exist until you have traffic. That's the genuine difficulty here rather than an oversight: a pilot can't measure what a pilot doesn't have. What it can do is record the shape it does see, so the forecast is built from something rather than assumed. Culpa prices every call from a versioned price book in exact decimal and keeps the token shapes alongside the costs, so cost per call is a series you can watch climb rather than a constant you set once. Every forecast is stored and scored against what actually happened, which is what turns the second forecast into something better than the first.
Questions founders ask next
Why did production cost more than the pilot predicted?
Usually conversation length and retries. A pilot runs short sessions with no retry rate, and both push real cost per call up. In the modelled example a pilot figure of $0.0110 became $0.01955 in production, so a $55,000.00 forecast landed at $97,750.00.
How should I forecast from a pilot?
Forecast the shape rather than the total. Take your real conversation length, an assumed retry rate and a skewed usage distribution, price those, and give a range. The pilot's cost per call is the least transferable number it produces.
Does anything get cheaper at scale?
Yes, and that's what makes this confusing. Caching a large prompt loses money at pilot volumes, because a cache write costs more than base input and a pilot doesn't read it enough times to break even. The same cache pays clearly in production, so a pilot can be pessimistic and optimistic at once.
What should the pilot actually measure?
Token shapes, not dollars. How long conversations really run, what share of calls retry, and how skewed usage is across users. Those three transfer to production. The total bill doesn't, and it's the thing everybody writes down.
On your infrastructure
Culpa runs on your infrastructure. Your prompts and responses never leave it. Culpa counts calls to run your plan, and it fails open, so if it ever breaks your app keeps running.
How Culpa works
Find the culprit. Not just the total.
Your dashboard shows what you spent. It stops short of who spent it. Culpa shows the conversation, the user and the feature behind it.
Your prompts stay local.
Culpa runs on your own infrastructure. What you send to a model reaches us at no point.
Every dollar has a name.
Follow any charge to the conversation, the user, the feature and the customer behind it.
See the bill before it lands.
Cost your next feature before you ship it. You get the likely bill and the worst case, at best, median, p90 and p99.
Three steps to your first answer.
Change one base URL.
Or drop in the Python or TypeScript library.
Find your most expensive conversation.
In the first session, not the first week.
Cost your next feature before you ship it.
Why the bill went up
Example dashboardCalls traced
418,209
across 3 projects
Spend this week
$378.41
+ $182 vs last week
Failed calls
312
74% retried, and you paid for all of them
+ $182 this week traced to one culprit
Spend over 14 days
Most expensive users
Next week forecast
Graded against reality. Accuracy shown as results land.
Keep reading
Sources: Anthropic pricing. Last reviewed 2026-08-05, rates effective 2026-07-02. Plain text version.