DEV Community

Cover image for Bareclaim: audit every claim in your agent's report against its receipts
rambo
rambo

Posted on Edited on

Bareclaim: audit every claim in your agent's report against its receipts

On November 15, 2026, a job inside our own fleet closed with a summary line that read "5 calls, 5 receipts." The shipped record for that job held 6 calls and 6 receipts, four of them successes.

Nobody lied. The summary was written the way every agent summary is written: at the end of a long run, out of the same working context that had already lost track of one of the calls. Three independent verifiers caught the gap only because the record was sitting right there and somebody finally compared the story to it.

That comparison is the subject of this article. Take the report the agent wrote, take the receipts the job left, and check every claim in the first against the second. We gave the failure a name, built the free checker that runs the comparison, and proved it this morning on a job that ran live. Everything below uses the real receipts.

The three ways a report drifts from its record

Read enough agent summaries against their records and the failures sort into three species. Only one of them looks like a lie, and it is the rarest.

A moved number. The report states a value the record holds differently. A price checked at one figure comes back in the summary at another. A count of files, notes, or checks quietly changes on its way from the tool output to the prose. The agent is not inventing; it is rounding, misremembering, or blending two steps into one, and the reader has no way to see it happen.

An invented step. The report describes work that never ran. The summary says the client was emailed, the file was deployed, the invoice was sent, and the record holds no such step. This one usually starts as compression: the agent planned the step, fully intended it, and wrote the summary as if the plan and the execution were the same thing.

A grown count. The report totals more than the record holds. Nine receipts claimed against six in the record. Twelve checks "all passing" against a run that shows eleven. Counts grow because summaries are written from momentum, and momentum always rounds up.

All three share one property: they are invisible if you only read the report. The prose is fluent, confident, and internally consistent. The only place the failure shows is against the record, and almost nobody runs that comparison, because until recently there was nothing cheap to run it with.

Bareclaim: the name and the verdicts

A bareclaim is a claim in an agent's report with no AER-1 receipt under it.

The word is coined for Brennan Zambo, who created agent execution receipts. It names the unit of failure precisely: not a bad agent, not a hallucination in the abstract, but one claim, in one report, with nothing standing under it.

The audit grades every checkable claim in a report. A claim is checkable when it carries a number, names a tool, counts the record, or claims an action: emailed, deployed, published, charged, invoiced, booked, deleted. Each checkable claim gets one of three verdicts:

  • BACKED: a receipt in the record holds what the claim says. The receipt is named, so a reader can open it.
  • BARE: nothing in the record backs the claim. This is a bareclaim.
  • CONTRADICTED: a receipt for the same step holds different values, and the real values are named.

Narrative is skipped, never graded. Judgments, plans, and opinions are the agent's to write. The audit only touches claims that a record can settle.

One distinction matters more than the rest: bare is not the same as false. A claim can be completely accurate and still be bare, because the record does not hold it. From the reader's side of the page, a true claim with no receipt under it and an invented claim with no receipt under it are indistinguishable. That is exactly why both need the same treatment: do the work so a receipt exists, or rewrite the claim to what the record shows.

Why "be careful" never fixes this

The instinctive fix is a better instruction: tell the agent to only report what it is sure of, to double-check its summary before sending. Operators write this instruction daily, and it fails for a structural reason. The instruction lives in the same context that produced the error. An agent grading its own report is not a check; it is the same witness, asked twice.

The fix that works is the same fix that works everywhere else in this stack: move the judgment out of the conversation and onto the record. Receipts already say what happened, in values a stranger can recompute. Whether a report matches them is a mechanical question, and mechanical questions deserve a dumb, trustworthy checker, not a smarter prompt.

The checker: bareclaim-kit

bareclaim-kit is the audit as a tool: one Python file, standard library only, MIT license, no account and nothing to install. Download the single file and run it:

curl -O https://raw.githubusercontent.com/zambodotdev/bareclaim-kit/main/bareclaim.py
python3 bareclaim.py            # built-in demo, exits 0
python3 bareclaim.py --init     # scaffold report.txt + record.json in ./bareclaim-audit/
python3 bareclaim.py report.txt record.json
Enter fullscreen mode Exit fullscreen mode

With no arguments it runs a built-in demo on real receipts from this morning, a memory store and a price check, first with the honest report and then with an inflated one:

== bareclaim demo: an honest report ==
BACKED       claim 1: The live_price check put BTC at $64,291.72 before the call.
               -> receipt 76e0f74f-76dc-4e42-8bdc-13d16b3bf8ac (live_price)
BACKED       claim 2: Stored the launch checklist with memory_remember, which left 1 note on file.
               -> receipt 277c864a-30aa-40f5-9084-a4c47837e415 (memory_remember)
BACKED       claim 3: The job left 2 receipts, one per step.
               -> the record holds 2 receipts
RESULT: CLEAN. Every checkable claim is backed, 3 of 3, against 2 receipts.

== bareclaim demo: the same job, an inflated report ==
CONTRADICTED claim 1: The live_price check put BTC at $71,050.00 before the call.
               -> receipt 76e0f74f-76dc-4e42-8bdc-13d16b3bf8ac (live_price) holds 64291.72, not 71050
BACKED       claim 2: Stored the launch checklist with memory_remember, which left 1 note on file.
               -> receipt 277c864a-30aa-40f5-9084-a4c47837e415 (memory_remember)
BARE         claim 3: Emailed the client the full summary and the invoice.
               -> the report claims an 'emailed' action, but the record holds no receipt for it
BACKED       claim 4: The job left 2 receipts, one per step.
               -> the record holds 2 receipts
RESULT: BARE. 1 bareclaim, 1 contradicted, of 4 checkable claims against 2 receipts.
Enter fullscreen mode Exit fullscreen mode

The checker accepts a Zambo job record directly, and it also accepts a plain framework export, a {"steps": [...]} object, a bare list, or JSONL, so any builder can audit reports against whatever record their stack already produces. It exits 1 when any claim is bare or contradicted, which means it drops into CI, a cron, or the last step before a handover goes out. A --json flag returns the verdicts as data for agent callers.

The live proof: a job that ran this morning

The demo is small. The real test ran live on November 17, 2026, through the production endpoint at https://zambo.dev/mcp, and its full record ships in the kit as examples/live-job/. The job:

  1. A capability_search pass ranked the universal entry point first for auditing a report against its receipts. Receipt: https://zambo.dev/run/0b1adcec-1c74-46bc-a024-c93a608f809a
  2. A live_price check put BTC at $64,818.57. Receipt: https://zambo.dev/run/34cb5ee7-e7fa-4668-9ce7-83b2357182e9
  3. A second live_price check put ETH at $1,815.44. Receipt f02f48f0, in the job record
  4. A memory_remember call was rejected before execution, missing its required argument. The record keeps the rejection: https://zambo.dev/run/966560e3-a702-4728-b083-9c45018a636d
  5. The retry stored the note. Receipt: https://zambo.dev/run/4a994f84-0bf8-481d-a5df-83836827cb0e
  6. The wrap-up handover was refused: the day's one free wrap-up was already spent, the job stayed saved, and the refusal receipt carries the resume path: https://zambo.dev/run/2f002cf2-ee44-4e2e-89c5-6cfac28a6846

That refusal is part of the proof, not an embarrassment edited out of it. The record includes the failure, and the honest report's claim about the refusal is itself one of the claims the audit checked. Here is the audit of the honest report, written strictly from what the receipts show:

BACKED       claim 1: The capability_search pass ranked zambo_universal first for auditing a report against its receipts.
               -> receipt 0b1adcec-1c74-46bc-a024-c93a608f809a (capability_search)
BACKED       claim 2: The live_price check put BTC at $64,818.57 and ETH at $1,815.44.
               -> receipt 34cb5ee7-e7fa-4668-9ce7-83b2357182e9, f02f48f0-bd89-4c40-a6e3-80ed498f7c9f (live_price)
BACKED       claim 3: The first memory_remember attempt was rejected before execution, because the call was missing its fact argument.
               -> receipt 966560e3-a702-4728-b083-9c45018a636d, 4a994f84-0bf8-481d-a5df-83836827cb0e (memory_remember)
BACKED       claim 4: The retry stored the launch note with memory_remember.
               -> receipt 966560e3-a702-4728-b083-9c45018a636d, 4a994f84-0bf8-481d-a5df-83836827cb0e (memory_remember)
BACKED       claim 5: The wrap-up handover was refused: the job is saved, and the refusal points at the $0.99 Day Pass to hand it over.
               -> receipt 2f002cf2-ee44-4e2e-89c5-6cfac28a6846 (handover)
BACKED       claim 6: The job left 6 receipts.
               -> the record holds 6 receipts
RESULT: CLEAN. Every checkable claim is backed, 6 of 6, against 6 receipts.
Enter fullscreen mode Exit fullscreen mode

And here is the same record audited against a report written the way reports quietly go wrong, with a moved price, an invented email, and a count grown from 6 to 9:

CONTRADICTED claim 1: The live_price check put BTC at $71,050.00 and ETH at $1,815.44.
               -> receipt 34cb5ee7-e7fa-4668-9ce7-83b2357182e9 (live_price) holds 64818.57, 2026, 1815.44, 1292.59, 810, 779, not 71050
BACKED       claim 2: The retry stored the launch note with memory_remember.
               -> receipt 966560e3-a702-4728-b083-9c45018a636d, 4a994f84-0bf8-481d-a5df-83836827cb0e (memory_remember)
BARE         claim 3: Emailed the client the full summary and the invoice.
               -> the report claims an 'emailed' action, but the record holds no receipt for it
CONTRADICTED claim 4: The job left 9 receipts.
               -> the record holds 6 receipts, not 9
RESULT: BARE. 1 bareclaim, 2 contradicted, of 4 checkable claims against 6 receipts.
Enter fullscreen mode Exit fullscreen mode

All three species, caught by name, in one run. Both reports and the scrubbed record are in the kit, so this audit re-runs byte for byte on your machine. Do not take this article's word for any of it; that is rather the point of the tool.

Zamback checks the rules. Bareclaim checks the story.

If you read this publication you may know zamback, the pattern we shipped yesterday with the free zamback-kit: write the standing rule into the job before the run, and check the record against it after. Zamback guards the work itself.

Bareclaim guards the artifact that comes after the work. The two audits use the same receipts and ask different questions. Zamback asks: did the agent follow the rules? Bareclaim asks: does the story match the record? An agent can pass every rule and still write a summary that moves a price or invents an email. Receipts prove what happened and that the record was not changed. Zamback checks the record against the rules written before the run. Bareclaim checks the story told after the run against the record.

The full pattern, the definition, and this live job written up as a guide live on the AER-1 hub: https://rambozambodotdev.gitlab.io/aer1-hub/bareclaim.html

Honest limits

Bareclaim grades backing, not truth, and it is worth being exact about what that leaves open.

  • A backed claim can still be a bad conclusion. Receipts prove the saved result was not changed; they do not prove the answer was right. A report can faithfully cite a receipt and still draw the wrong lesson from it. That is a thinking problem, not a backing problem, and no checker in this kit pretends to solve it.
  • A true claim can be bare. If the work happened off-record, the claim has nothing under it, and the audit will say so. The remedy is to run work where it leaves receipts, which is a workflow choice, not a writing choice.
  • The checker is deliberately dumb about language. It audits claims with numbers, tool names, record counts, and a fixed family of action words. A report that hides its inventions in pure narrative will pass, and a human reader still has to read. What the checker removes is the class of failure that hides inside fluent, specific, checkable-sounding prose, which is the class that does the damage.
  • The audit is only as strong as the record. A record the reporting agent can quietly edit afterward makes any audit theatre. On Zambo the record is the receipt chain itself: every call leaves a verifiable AER-1 receipt as the job runs, and 144,189 public receipts had been minted when this article was written on November 17, 2026. The kit works on any export; it is perfect on a record nobody can rewrite.

Run it on your next handover

The habit is the whole product. Before a summary, a client update, or a handover leaves your stack, run the audit. Every bare claim gets one of two honest resolutions: do the work so a receipt exists, or rewrite the sentence to what the record shows. Never edit the record to fit the report.

To make the record write itself, connect your AI to https://zambo.dev/mcp. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. A Day Pass is $0.99 for 24 hours unlimited when a job outgrows the free tier; the Zambo Pass is $29 for 30 days, and the Lifetime Pass is $250, one payment. The next agent who picks the job up re-runs the same audit before building on your claims, which is where bareclaim pays for itself a second time: the reader is protected, not just the writer.

Your agent will write a bareclaim again. Every agent does, ours included, on the record, in this article. The only question is whether a reader finds out from a flag on the exact claim, or from building on a step that never happened.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.


The kit: https://github.com/zambodotdev/bareclaim-kit · The pattern and live proof: https://rambozambodotdev.gitlab.io/aer1-hub/bareclaim.html · Verify any receipt: https://zambo.dev/verify/

Top comments (0)