Can an AI agent invoice prove what it really ran?

The problem: bills you cannot audit

Agents charge by the token, by the tool call, by the minute, by the task. The invoice arrives as a line item: run 84f2, $4.71. What did run 84f2 do? Which tools ran, how many calls, what came back? In most setups, the answer is a second dashboard you have to trust, run by the same party that billed you.

This is not a rounding problem. When the agent decides how many child tasks to spawn, which model tier to escalate to, and which tools to call, the difference between a $4 run and a $40 run is invisible to the buyer. Without per-call evidence, every invoice is a trust-me statement from the system that wrote the bill.

What an itemized agent invoice should contain

A trustworthy agent invoice answers five questions per line item:

1. What ran. The tool or model call, identified by name, and which agent or sub-agent called it.
2. When it ran. An execution-time timestamp, not a billing-time guess.
3. What it consumed. The exact input bytes and the observed output bytes, so cost maps to real work.
4. How much it cost. The billed amount tied to that specific call, not an aggregate.
5. How to check it. A receipt with a cryptographic commitment over the canonical bytes, verifiable by anyone without an account.

Most billing dashboards give you the fourth item and hide the rest. That is the gap a verifiable receipt closes.

How AER-1 turns a bill into evidence

AER-1 is a verifiable execution receipt format, published as the IETF Internet-Draft draft-zambo-aer1. Every tool call produces a receipt minted by the execution layer, not the agent:

• The tool, the calling agent, and the execution timestamp
• Canonical input and output bytes for that call
• A SHA-256 commitment over those bytes
• Sequence position, so a missing call shows up as a visible gap

Attach one receipt per billed line item and the invoice becomes self-auditing. Dispute a charge and the vendor hands you receipts, not screenshots. Recompute one hash and you know whether the bill matches reality. The receipt is the invoice's proof of work.

The dispute test

Before paying an agent invoice at scale, run one test: ask for the receipt behind the most expensive line item. A vendor that can produce per-call verifiable receipts has an evidence chain. A vendor that sends you a dashboard export has a hope.

Receipt this invoice: the copy-paste version

If you run an agent service, you can attach a verifiable receipt to every billed line item today. Record each tool call with the aer-1 kit, save the receipts next to the invoice, and hand the customer a file they can check without your dashboard.

// invoice-this-run.mjs
import { AER1Recorder } from "aer-1";

const recorder = new AER1Recorder({ scope: "invoice-2026-10" });

// one record per billed line item: the tool, the cost, the output
function bill(tool, costUSD, output) {
  const receipt = recorder.record(tool, { cost_usd: costUSD }, output);
  console.log(tool, costUSD, receipt.id);
  return receipt.id;
}

bill("web_search", 0.012, searchResult);
bill("code_exec", 0.084, execResult);

recorder.save("invoice-2026-10.receipts.jsonl");

Ship invoice-2026-10.receipts.jsonl with the bill. It holds one canonical receipt per line, and the customer can check any single line with the free offline verifier, no account needed:

pip install aer1-verify
sed -n '1p' invoice-2026-10.receipts.jsonl > line1.json
aer1-verify line1.json

Once a customer has verified one invoice line by line, they will expect the same evidence on every invoice. That expectation is the moat: the receipt habit outlives any single vendor.

Start with one free receipt

You can hold a real verifiable receipt in your hands before paying anything. The live demo runs one real tool call and mints a real AER-1 receipt, free, with no signup. That receipt is the same primitive an itemized agent invoice would attach to every line.

Run one free call and see the receipt behind the line item.