AgentLedger sits between your apps and the models. It picks the cheapest suitable model per task, actually forwards the call, and records what happened — including what the backend itself chose. Measuring, routing and accounting are one mechanism here, not three tools.
Self-hostable · no prompt content stored unless you turn it on · a product of Neuralex
Agentic AI burns multiples of what chat does, and retries plus context push it further. That difference sits in tokens you never see, because they are not in the answer but in the question.
The moment you run subscriptions and API keys side by side, nobody can say per task which was cheaper. The two streams have to be counted separately — a subscription call is not an expense.
Whatever your tool cannot price, it usually books as € 0.00. The total looks healthy and nobody sees a piece is missing. We did exactly this ourselves, and it took months to notice.
Not a separate meter next to a separate proxy: the same movement that forwards the call also writes the measurement.
A router that actually forwards. One OpenAI-compatible endpoint for all your apps, streaming included, with fallback when a provider goes down.
Routes per app. Automatic, a fixed model, let AgentLedger choose, or off. An empty policy equals exactly the old behaviour.
A decision trail per call. Which task type, which route setting, which destination, which backend really executed it, and what that cost.
Honest pricing. Five pricing states. Unpriced is empty, not zero — and any total containing one is called a lower bound.
A spending brake. An hourly limit on real spend; above it, paid calls go to the free model. It never fires on subscription value.
Loop and ghost detection. Repeating near-identical calls are flagged even when free — a free loop still costs quota and time.
Failures with a reason. Failed calls keep why they failed, instead of only returning a 502 to the client.
Coverage per provider. Exact API measurement, usage estimate or OAuth bridge — stated out loud rather than blended together.
Balances and subscriptions. How full each window is, at what pace, when it resets, and which trial is about to expire.
Native Mac app. Fourteen screens on a local API; the router itself stays a separate process that keeps running without the app.
Screenshots from 19 August 2026 with real production data from our own lab. Nothing was drawn in and nothing polished away — the failed calls and the unpriced gaps are simply there.
Not zero — unknown. The governor did not report which endpoint it picked, so no rate applies. The panel spells it out: the amount is not zero but unknown, this call counts nowhere, add the rate to make it count.
Four modes per app, an optional hourly limit, and a note field for yourself three months from now. The forty callers that have not identified themselves sit at the top instead of vanishing into one anonymous pile.
Above the list the total, directly below it what that total is worth: lower bound — 644 of 5,000 calls without a rate. That line is the difference between a number and a claim.
The price book the router really uses, searchable per model. Note the last row: a free endpoint at EUR 0.000. That is what makes a free call provable instead of guessed.
Sessions per app with tokens in and out, cost, failed and unpriced calls counted separately, plus the models that session actually used.
Off means off: the router rejects every call to that provider and the advisor never picks it. At the bottom, the search sources for the news route, with automatic fallback.
Every call carries a pricing state. That is not a detail — it is the difference between a number that holds and a number that merely looks like it does.
Set your app's base URL to the router. One line per app; your stack stays as it is.
Every call becomes one row: source, task type, route, real upstream, tokens, cost or the gap, duration and status.
An empty policy changes nothing. Only when you put an app on a fixed or cheaper model does the router start steering.
| Tool | Focus | Routes itself | Shows its gaps |
|---|---|---|---|
| Langfuse | Observability + cost | No | No |
| Helicone | Gateway + logging | Yes | No |
| Portkey | Gateway + guardrails | Yes | No |
| Datadog LLM Obs | Enterprise observability | No | No |
| AgentLedger | Router + ledger + governance | Yes | Yes |
This comparison is about design choices, not a test report. Do not mistake it for a benchmark — and check the columns yourself before you pick anything.
Beta here means: it runs in production every day on one homelab, with real costs and real failures — and it is not ready to hand to anyone else.
There is deliberately no rate on this page and nothing to order. Once AgentLedger is installable outside our own lab, a pricing model will appear here — and only then a release date. Want to look along or think along while that happens? Let us know and we will keep you posted.