AgentLedgercost & governance
Beta · no release date yet

Know what every agent task costs,
and whether you can trust it.

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.

Where it stands. AgentLedger runs in production in our own homelab and is in beta. There is deliberately no release date and no price list yet: measurement coverage per provider has to be finished first. A measuring instrument that papers over its own gaps is worse than none at all.

Self-hostable · no prompt content stored unless you turn it on · a product of Neuralex

67,309calls in the ledger
8providers behind one router
9apps recognised automatically
14screens in the Mac app
AgentLedger overview: spend today, calls, savings, spend per hour with the hourly limit, errors in the last 24 hours and the status of every lane
Overview — spend today, the hourly limit in view, and the last 24 hours of errors with their source. Real production data, 19 August 2026.

The problem

Three things your dashboard does not tell you

The bill surprises you

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.

Subscription or API?

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.

A gap gets booked as zero

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.

What it does

The things happening at the core

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.

From the running app

Six screens, unretouched

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.

Detail view of one call with a panel explaining that no rate is known for the endpoint that ran it
Decision trailA call that counts nowhere, and says so

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.

Routes per app with four modes and a list of recognised apps
RoutesWhich app goes to which model

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.

Sessions screen with totals and the note that 644 of 5,000 calls had no rate
SessionsUsage with the gaps left in

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.

Pricing screen filtered on deepseek, with one endpoint listed at EUR 0.000
PricingFree is a rate, not an assumption

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.

Live screen with active sessions per app
LiveWhat is running right now

Sessions per app with tokens in and out, cost, failed and unpriced calls counted separately, plus the models that session actually used.

Providers screen with a toggle per provider and the search sources for the news route
ProvidersSwitch off what you do not trust

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.

The core of the design

A gap must not become a zero

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.

pricedrate known, amount computed from the actual upstream
freeexplicitly € 0.00 in the price table — proven, not assumed
subscriptioncovered by the monthly fee; never triggers the spending brake
localruns on your own hardware; no invoice, but time and power
unpricedempty, not zero — the total is then called a lower bound

How it works

Three steps, no rebuild

1

Point your apps at it

Set your app's base URL to the router. One line per app; your stack stays as it is.

2

Let it measure

Every call becomes one row: source, task type, route, real upstream, tokens, cost or the gap, duration and status.

3

Set routes — or don't

An empty policy changes nothing. Only when you put an app on a fixed or cheaper model does the router start steering.

Positioning

Everyone measures tokens. Almost nobody admits their own measurement gaps.

ToolFocusRoutes itselfShows its gaps
LangfuseObservability + costNoNo
HeliconeGateway + loggingYesNo
PortkeyGateway + guardrailsYesNo
Datadog LLM ObsEnterprise observabilityNoNo
AgentLedgerRouter + ledger + governanceYesYes

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.

Status

What is done, what is running, what is waiting

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.

Done

  • Router with streaming and fallback across 8 providers
  • Routes per app, with source detection per call
  • Pricing state per call and lower-bound marking
  • Upstream recording: what the backend really chose
  • Failures with a reason, loop and ghost detection
  • Native Mac app with fourteen screens

Running

  • Finishing coverage for providers still on estimates
  • Filling in rates for models that now arrive unpriced
  • Verdict engine: production-worthy, review or reject
  • Remote access behind Cloudflare Access

Waiting

  • Installation outside our own lab
  • Self-improvement: routes as a proposal, never applied silently
  • Report export for client or board
  • Pricing model and release date

Pricing

Not for sale yet

No price list while it is in beta

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.

From “the model decided” to “here is exactly what it did, what it cost, and where we are not sure.”