Guides / culpa vs literal ai

Culpa vs Literal AI

Literal AI was an LLMOps platform, discontinued with service running until 2025-10-31. It priced calls from a price book you configured and dated yourself. Culpa, a local-first LLM cost, margin, and forecast ledger, ships that price book versioned and maintained, prices every call from it, and forecasts next month from your own history.

Why this happens

Literal AI got the architecture right and handed you the maintenance. Its cost tracking asked you to configure, per model, a Pattern as a regular expression such as gpt-4o followed by a wildcard, an Input Price in USD per million tokens, an Output Price in the same unit, and optionally a Period with start and end dates that its own docs describe as useful for handling price changes. That's an effective-dated price book, which is the correct shape and the same one Culpa uses. Two differences decide how it behaves in practice. The rates were yours to enter and yours to keep current, so a page of settings quietly became the thing your cost reporting depended on. And matching by regular expression means a pattern written for one family silently catches the next model that shares its prefix, at last year's rate. The dashboard then showed total cost, cost per conversation and a breakdown by model. The company discontinued the product with service available until 2025-10-31, saying it couldn't differentiate enough in a competitive market to build sustainable revenue.

What this usually looks like

  • Your model rates live in a settings page and nobody remembers who last updated them.
  • A new model in a familiar family started billing at an older model's rate.
  • Cost reporting was right last quarter and nobody can say whether it still is.
  • You have cost per conversation and no way to set it against what that customer pays.
  • A price change landed mid-month and your totals reflect one rate for the whole period.

Free, no card, no account

Run the free Cost Leak Scan

It shows your most expensive conversation before you install anything.

Run a free scan

Mistakes that cost the most

MistakeWhy it hurtsDo instead
Matching models by prefix pattern.A pattern written for one family catches its successor automatically, and prices it at the old rate without warning.Match exact model identifiers, and let an unknown model fail loudly rather than price wrongly.
Keeping your rate card in a settings page.It becomes tribal knowledge with no version history, no review, and no way to explain last quarter's numbers.Keep rates versioned with effective dates, so any past month can be recomputed exactly as it was billed.
Reading cost per conversation as margin.Literal AI had cost per conversation. Margin needs the revenue that conversation earned, which no observability tool holds.Join spend to revenue, or accept that you're measuring cost and not profitability.
Assuming a mid-month price change applies cleanly.Without dated rates, one month gets a single rate and the arithmetic quietly stops matching the invoice.Use effective-dated rates so each call prices at the rate in force when it ran.

Run this check tonight

  1. Find where your model rates are stored and who last changed them.
  2. Add a new model in an existing family and check which rate it picked up.
  3. Recompute a month from six months ago and see whether it matches what you reported then.
  4. Ask your tool for cost per customer against what that customer pays you.
  5. Check what happens to pricing on the day a provider changes a rate mid-month.

What a prefix pattern does on the day a family gains a member

Literal AI matched models by regular expression, its own docs giving gpt-4o with a wildcard as the example for all GPT-4o variants. Model families gain members and the new member rarely shares the old rate. Take 10M input tokens billed under a pattern written for a $2.50 per million tier when the call actually ran on a $5.00 per million model that the pattern also matched. Rates are real points from the price book effective 2026-07-02, and the volume is modelled.

10M input tokens at the intended $2.50 per million = $25.00
10M input tokens at the actual $5.00 per million = $50.00
the pattern reports $25.00 against a true $50.00, understating by $25.00
understatement is 50% of true spend, and nothing in the tool flags it

A wrong rate is worse than a missing one, because a missing rate is visible. Culpa matches exact model ids and records cost_complete as false when a model is absent from the book, so an unpriced call shows up as unpriced instead of silently taking a neighbour's rate.

Every number, with its confidence and source

FigureWhat it meansConfidenceSource
$25.00understatement on 10M input tokens when a prefix pattern prices a $5.00 model at a $2.50 ratecalculatedPattern matching behaviour from docs.literalai.com/guides/settings/llm, read 2026-08-03, which gives a regular expression on the model name as the matching mechanism. Rates of $2.50 and $5.00 per million input tokens are real points from the price book effective 2026-07-02. Token volume and the mismatch scenario are modelled: 10 x $2.50 = $25.00 reported against 10 x $5.00 = $50.00 true, a $25.00 gap.

What a generic answer can’t know

Literal AI is the closest thing in this cluster to Culpa's own design, which makes the comparison narrow and specific rather than sweeping. Both price calls from a rate table with effective dates. Both report cost broken down by model and by conversation. Three things differ. Culpa ships the price book versioned and maintained, extracted from the ledger's own migrations, so nobody's settings page is the source of truth. Culpa matches exact model identifiers and marks a call incomplete when the model is unknown, rather than matching a prefix and quietly pricing at whatever the pattern caught. And Culpa carries the revenue each customer pays you, so cost per conversation becomes margin per customer, which is the question Literal AI's dashboard couldn't reach. The product was discontinued with service until 2025-10-31, so this compares a design rather than a purchase.

Questions founders ask next

When did Literal AI shut down?

Its own migration guide says the service remained available until 2025-10-31. The team wrote that it couldn't differentiate enough in a competitive market to build sustainable revenue, discontinued Literal AI, and sought a new maintainer for Chainlit. The documentation is still online.

How did Literal AI track LLM cost?

Through a price book you configured. Per model you set a Pattern as a regular expression, an Input Price and an Output Price in USD per million tokens, and optionally a Period with start and end dates that the docs describe as useful for handling price changes. The dashboard then showed total cost, cost per conversation and a breakdown by model.

What did Literal AI recommend that users move to?

Its guide names LangSmith, Langfuse, or a self-hosted open source data layer for teams that want storage without observability or evaluation. It also advises choosing something that supports OpenTelemetry. Culpa isn't on that list and this page doesn't pretend otherwise.

What's wrong with matching models by pattern?

It fails silently in the direction you can't see. A pattern written for one family catches the next model with the same prefix and prices it at the older rate, so your reporting stays confidently wrong. Exact matching with an explicit incomplete flag turns that into a visible gap instead.

Is Culpa just a rebuild of Literal AI's cost tracking?

The rate table with effective dates is the same idea and worth crediting. What Culpa adds is who maintains it, exact model matching with an incomplete flag, exact decimal money, the revenue each customer pays you, and a forecast of next month. Literal AI stopped at cost per conversation, which is attribution rather than margin.

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.

1

Change one base URL.

Or drop in the Python or TypeScript library.

2

Find your most expensive conversation.

In the first session, not the first week.

3

Cost your next feature before you ship it.

Base URLhttp://localhost:4545/v1Your traffic keeps flowing if Culpa ever stops.

Why the bill went up

Example dashboard

Calls 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

$0$20$40$60$8024262830020406
user_384report_generatorconv_91fprompt_v1894,220 tokens3 retries$6.81

Most expensive users

user_384$38.42
user_119$21.07
user_562$14.90
user_204$8.30
user_871$5.10

Next week forecast

Best$180
Median$240
p90$310
p99$395

Graded against reality. Accuracy shown as results land.

Free, no card, no account

Run the free Cost Leak Scan

It shows your most expensive conversation before you install anything.

Run a free scan

Keep reading


Sources: Literal AI migration guide, Literal AI cost tracking settings, Literal AI dashboard. Last reviewed 2026-08-03. Plain text version.