Metered intelligence, settled on-ledger.

Ambrin turns inference, GPU time and data feeds into tokenized credits. Agents spend them per call, and every call leaves a private, verifiable receipt.

Request access See a receipt

research-agent-07 session Simulated

$ call inference.north/chat

✓ 2,310 tok · 0.004620 cr

$ call feeds.lantern/fx-spot

✓ 1 query · 0.000400 cr

$ call inference.north/chat

✓ 1,127 tok · 0.002254 cr

$ call inference.north/chat

✓ 904 tok · 0.001808 cr

$ call feeds.lantern/fx-spot

✓ 1 query · 0.000400 cr

$ call inference.north/chat

✓ 1,842 tok · 0.003684 cr

$ call feeds.lantern/fx-spot

✓ 1 query · 0.000400 cr

$ call gpu-pool-eu/a-class

✓ 18 GPU-s · 0.225000 cr

Credit balance

249.7614cr

Daily budget

8.43 / 25 cr

Receiptsprivate to buyer + provider

gpu-pool-eu18 GPU-s · rcpt_c41e07
−0.225000
feeds.lantern1 query · rcpt_a90b3d
−0.000400
inference.north1,842 tok · rcpt_7f3a9c
−0.003684
inference.north904 tok · rcpt_52d8e1
−0.001808

The problem

Agents spend all day. The bill arrives next month.

Agents pay for inference, GPUs and data the way a web app did ten years ago: one shared API key and a monthly invoice. That holds up for one service. It falls apart with forty agents making thousands of calls an hour.

1
One key, many agents

Every agent draws on the same key and the same account. There is no budget per agent, so one runaway loop spends everyone's money.
2
An invoice is not a record

The provider sends one total at month end. It can't tell you which agent made which call, or what that call cost.
3
Reconciliation after the fact

You learn what happened by joining logs against a bill, weeks later, and trusting that both sides counted the same way.

How it works

Capacity in. Credits out. A receipt for every call.

01
Providers tokenize capacity

A provider lists inference, GPU time or a data feed and issues credits against it. Each credit is a claim on metered units at a stated price.
02
Agents buy credits

The agent's owner funds a wallet and sets a budget. The agent holds credits only for the providers it is allowed to use.
03
Credits are spent per call

Each call states its units. Credits move from the agent to the provider as the call is served. No shared key, no running tab.
Receiptrcpt_7f3a9c
- Credits transferred
- Receipt created
- Buyer + provider only
04
The call settles and emits a receipt

Payment and receipt are one atomic transaction. Either both happen or neither does.

What's metered

Three kinds of capacity. One way to pay for them.

Inference, metered by the token

Input and output tokens are counted on every call and priced per unit. The receipt carries both counts.

Unit: tokens
Input and output are counted separately, each at its own unit price.
Budget per agent
Cap spend per call, per day or per task. A call over budget fails before it runs.
Model on the receipt
The receipt names the model and version that served the call.

Inferenceinference.north

const res = await agent.call("inference.north/chat", {
  model: "north-large-2",
  messages,
  maxSpend: "0.02 cr",
});

res.receipt.units; // { input: 1204, output: 638 }

1,842 tokens×0.000002 cr=0.003684 cr

GPU time, metered by the second

Start a job, stream usage, stop when it's done. Credits are drawn down while the job runs and the last receipt closes the session.

Unit: GPU-seconds
Charged for the seconds a job holds the device, priced by device class.
Streaming spend
Long jobs settle in intervals, so a crash never leaves an open tab.
Hard stop at the cap
When the session budget is spent the job is halted and the receipt is final.

GPU timegpu-pool-eu

const job = await agent.run("gpu-pool-eu/a-class", {
  image: "trainer:4.2",
  maxSpend: "12 cr",
});

await job.done(); // 312 GPU-seconds, 1 receipt

312 GPU-s×0.0125 cr=3.900000 cr

Data feeds, metered by the query

Price feeds, search indexes, licensed datasets. Each query is one metered unit, or priced by the rows it returns.

Unit: queries or rows
The provider picks the unit. The receipt states which one was counted.
Scoped to a feed
Credits are tied to a feed. An agent can only spend where its owner allowed it.
Nothing leaks sideways
A feed provider sees receipts for its own feed and nothing about your other spend.

Data feedfeeds.lantern

const fx = await agent.query("feeds.lantern/fx-spot", {
  pairs: ["EUR/USD", "USD/JPY"],
  maxSpend: "0.01 cr",
});

fx.receipt.total; // "0.0004 cr"

1 query×0.0004 cr=0.000400 cr

Provider names, units and prices on this page are illustrative. Providers set their own unit prices.

The receipt

Every call leaves a receipt.

Not a log line you wrote yourself. A record both sides signed, created in the same transaction that moved the credits.

View as Buyer Provider Anyone else

The buyer sees the full receipt, plus its own wallet balance after the call.

What was called: Agent, provider, resource and model, with a call ID you can match to your own traces.
What it cost: Units, unit price and total. The arithmetic is on the receipt, not in a pricing page you have to look up.
Who can see it: The buyer and the provider. Nobody else on the network receives it.

Receipt

Settled

rcpt_7f3a9c21e

Call: call_01JB2M8Q4T
Settled at: 2026-10-01 14:32:07 UTC
Agent: research-agent-07
Buyer: acme-agents::1220…9f3c
Provider: inference.north::1220…4be0
Resource: chat / north-large-2

Units	Unit price	Amount
1,204 input tokens	0.0000015	0.001806
638 output tokens	0.0000030	0.001914
Total		0.003720 cr

Contract: 00a4f1…d27e
Signed by: buyer, provider
Wallet after: 249.996280 crbuyer only

Audit trail

What every agent used, and what it cost.

Receipts roll up into a ledger the owner can query. Group by agent, by provider or by resource. Every total traces back to the individual calls behind it.

Usagelast 24 hoursSample data

Credits spent46.02cr

Calls18,204

Receipts18,204one per call

Over budget037 calls refused

Agent	Calls	Tokens	GPU-s	Queries	Spent	Daily budget
research-agent-07	6,412	9.8M	–	1,208	22.14 cr	89% of 25
trainer-agent-01	14	–	1,116	–	13.95 cr	70% of 20
pricing-agent-02	9,930	1.1M	–	9,105	5.92 cr	59% of 10
support-agent-11	1,848	2.4M	–	96	4.01 cr	80% of 5
4 agents	18,204	13.3M	1,116	10,409	46.02 cr

Provider	Resource	Calls	Units	Spent	Share of spend
inference.north	Inference	7,781	13.3M tokens	27.91 cr	60.6%
gpu-pool-eu	GPU time	14	1,116 GPU-s	13.95 cr	30.3%
feeds.lantern	Data feed	10,409	10,409 queries	4.16 cr	9.0%
3 providers		18,204		46.02 cr

Spend per hourcallsGPU job

Budgets that hold

A budget is checked in the same transaction that spends the credits. An agent can't overspend and settle up later.
Totals that trace back

Every number in the table is a sum of receipts. Open any row and you are looking at individual calls.
One view across providers

Inference, GPU time and data sit in the same ledger, in the same format, whoever sold the capacity.

Developers

A budget in the call. A receipt in the response.

Give each agent a wallet, set what it may spend, and call providers through one client. The receipt comes back next to the result.

One wallet per agent. No shared keys to rotate or leak.
Limits enforced before the call. Per call, per day or per task.
The same receipt shape everywhere. Inference, GPU time or data.

The SDK is in private preview. Names and signatures may change before release.

import { Ambrin } from "@ambrin/sdk";

const ambrin = new Ambrin({ party: process.env.AMBRIN_PARTY });

// One wallet per agent, with a hard budget.
const agent = ambrin.agent("research-agent-07", {
  budget: { perCall: "0.02 cr", perDay: "25 cr" },
});

const { output, receipt } = await agent.call("inference.north/chat", {
  model: "north-large-2",
  messages: [{ role: "user", content: "Summarise today's filings." }],
});

receipt.id;        // "rcpt_7f3a9c21e"
receipt.total;     // "0.003720 cr"
receipt.visibleTo; // ["buyer", "provider"]

import os
from ambrin import Ambrin

ambrin = Ambrin(party=os.environ["AMBRIN_PARTY"])

# One wallet per agent, with a hard budget.
agent = ambrin.agent(
    "research-agent-07",
    budget={"per_call": "0.02 cr", "per_day": "25 cr"},
)

result = agent.call(
    "inference.north/chat",
    model="north-large-2",
    messages=[{"role": "user", "content": "Summarise today's filings."}],
)

result.receipt.id          # "rcpt_7f3a9c21e"
result.receipt.total       # "0.003720 cr"
result.receipt.visible_to  # ["buyer", "provider"]

{
  "receipt": "rcpt_7f3a9c21e",
  "call": "call_01JB2M8Q4T",
  "agent": "research-agent-07",
  "buyer": "acme-agents::1220…9f3c",
  "provider": "inference.north::1220…4be0",
  "resource": "chat/north-large-2",
  "units": { "input_tokens": 1204, "output_tokens": 638 },
  "unit_price": { "input_tokens": "0.0000015", "output_tokens": "0.0000030" },
  "total": "0.003720",
  "unit": "cr",
  "settled_at": "2026-10-01T14:32:07Z",
  "contract_id": "00a4f1…d27e",
  "signatories": ["buyer", "provider"],
  "visible_to": ["buyer", "provider"]
}

Two sides, one ledger

For the agent, and for the capacity behind it.

For agent builders

Give every agent its own wallet and its own limit.

A wallet and a budget for each agent, not one key for all of them.
Calls fail closed when the budget is spent.
One receipt format across every provider.
An audit trail the person paying can read.

Request builder access

For capacity providers

Sell inference, GPU time or data as credits.

List capacity once and issue credits against it.
Get paid per call, at the moment of the call.
No invoice run, no collections, no arguments over counts.
You see receipts for your own capacity. Nothing else is exposed, to you or about you.

Talk to us about listing

Why on-ledger

Settlement, not invoicing.

Ambrin is built on the Canton Network, a public ledger where a contract is shared only with the parties to it. That is what lets a receipt be both private and provable.

Invoicingmeter now, charge later

Month endOne invoice
Net 30Payment
After thatReconciliation

Ambrinevery call settles as it happens

Each callPaid and receipted in one transaction
Month endA report. Nothing left to settle.

01Private to its stakeholders: A receipt is a contract between the buyer and the provider. Canton sends a contract only to the parties to it. Other participants don't see the amount, the counterparties, or that the call happened.
02Verifiable by both sides: Buyer and provider hold the same signed record. Neither can edit it afterwards, and either can prove what it says.
03Atomic: The credit transfer and the receipt are created in one transaction. There is no state where a call was paid for but not recorded, or recorded but not paid for.
04Nothing to reconcile: Payment happens at the call. Month end becomes a report, not a negotiation.

FAQ

Questions, answered plainly.

Ambrin is early. Where something isn't decided yet, we say so.

What is a credit?

A token a provider issues against capacity it has listed: tokens of inference, seconds of GPU time, or queries against a data feed. An agent's wallet holds credits for the providers its owner has approved, and spends them per call.

Who can see a receipt?

The buyer and the provider. On Canton, a contract is distributed only to its stakeholders, so other participants on the network never receive it. A provider sees receipts for its own capacity and nothing about what you spend elsewhere.

What happens when an agent hits its budget?

The call is refused before it runs. The budget check is part of the same transaction that spends the credits, so there is no way to overspend first and settle up afterwards.

How is this different from usage-based billing?

Usage-based billing meters now and charges later, on the provider's count. Ambrin settles each call as it happens and gives both sides the same signed record of it.

Do I need to write Daml or run a Canton node?

Agent builders work through the SDK. How participant nodes are hosted is something we are working out with early-access teams, and we'll publish it when it is settled.

What does it cost?

Pricing isn't published yet. Providers set their own unit prices. Every number on this page is illustrative.

Is Ambrin live?

Not yet. Ambrin is pre-launch and onboarding a small group of agent builders and capacity providers first. Leave your email below and we'll get in touch.

Meter your first call.

Ambrin is onboarding early agent builders and capacity providers. Tell us which side you're on and where to reach you.

Pre-launch. We'll only email you about access.

Metered intelligence, settled on-ledger.

Agents spend all day. The bill arrives next month.

One key, many agents

An invoice is not a record

Reconciliation after the fact

Capacity in. Credits out. A receipt for every call.

Providers tokenize capacity

Agents buy credits

Credits are spent per call

The call settles and emits a receipt

Three kinds of capacity. One way to pay for them.

Inference, metered by the token

Unit: tokens

Budget per agent

Model on the receipt

GPU time, metered by the second

Unit: GPU-seconds

Streaming spend

Hard stop at the cap

Data feeds, metered by the query

Unit: queries or rows

Scoped to a feed

Nothing leaks sideways

Every call leaves a receipt.

What every agent used, and what it cost.

Budgets that hold

Totals that trace back

One view across providers

A budget in the call. A receipt in the response.

For the agent, and for the capacity behind it.

Give every agent its own wallet and its own limit.

Sell inference, GPU time or data as credits.

Settlement, not invoicing.

Questions, answered plainly.

Meter your first call.