Bareclaim: a claim in your agent's report with no receipt under it

The job is done and the agent writes the summary: what it checked, what it changed, what it sent. That report is what the client reads and what the next agent builds on, and nobody checks it against the record. A bareclaim is any claim in that report with nothing under it. Bareclaim is the audit that finds them, claim by claim, before anyone has to trust the story.

Run the free checker: bareclaim-kit on GitHub, one file, zero dependencies, or open the live job record from this page and re-run the audit on it yourself.

Published November 17, 2026. Written against draft-zambo-aer1-26. The live job and every number on this page are from November 17, 2026.

The short answer

What a bareclaim is, and the audit that catches it

A bareclaim is a claim in an agent's report with no AER-1 receipt under it. The report says the price was checked at one number and the record holds a different one. The report counts nine receipts and the record holds six. The report says the client was emailed and no email step exists. Each of those is a bareclaim or its harder sibling, a contradicted claim. Bareclaim is the pattern and the free checker: audit every checkable claim in the report against the job's receipts, and get back BACKED, BARE, or CONTRADICTED for each, with the receipt or the real value named.

Receipts prove what happened and that the record was not changed. Zamback checks the record against rules written before the run. Bareclaim checks the story told after the run against the record. The word bareclaim was coined for Brennan Zambo, creator of Zambo and of AER-1, and the kit shipped on November 17, 2026.

The founding bareclaim: our own summary, caught by our own record

On November 15, 2026, a piece of work inside our own fleet closed with a summary line that reported "5 calls, 5 receipts." The shipped record for that same work held 6 calls and 6 receipts, four of them successes. The summary was not written by a careless outsider. It was written the way every agent summary is written: from the working context, at the end of a long run, by the same process that had done the work and already lost track of part of it.

Three independent verifiers caught it, because the record was sitting right there and somebody finally compared the story to it. That comparison is the whole discovery: the record existed, the receipts were public, and the check still was not a habit. Every operator running agents has this story in some costume. The summary that rounds a price into a different price. The handover that reports six checks run twice. The client update that adds a step which never happened, written in perfect confidence by an agent that believes it.

The report is the artifact the client reads, the artifact the next agent picks up, the artifact an invoice leans on. It is also the one artifact in the pipeline that, until now, nothing audited.

Why trusting the summary never fixes it

The instinctive fix is to instruct harder: tell the agent to be careful, to only report what it is sure of, to double-check its own summary. Operators do this daily, and it fails the same way reminding an agent of a rule fails: 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 is structural, and it is the same fix as everywhere else in this stack: move the judgment out of the conversation and onto the record. The receipts already say what happened, in values a stranger can recompute. The report either matches them or it does not, and that is a mechanical question a dumb checker can answer without trusting anyone, including the agent that wrote the report and the one running the audit.

The bareclaim pattern, in four moves

  1. Run the job so it leaves receipts. Every step: which tool, what went in, what came back, bound into a receipt at the moment the step runs. On Zambo this is automatic: every call through the Zambo MCP leaves a verifiable AER-1 receipt, and a job's receipts chain together. 144,189 verifiable public receipts had been minted when this page was written on November 17, 2026.
  2. Write the report the way you always do. Summary, handover, client update. Not written for the checker, written for the reader. The audit only works as a habit if the writing stays natural.
  3. Audit the report against the record. Every checkable claim comes back with one of three verdicts: backed, with the receipt named; bare, when nothing in the record backs it; or contradicted, when a receipt for the same step holds different values, which are named. Narrative is skipped, never graded.
  4. Fix the claim or do the work. A bare claim has exactly two honest resolutions: run the step so a receipt exists, or rewrite the sentence to what the record shows. Never edit the record to fit the report. Then hand the record, and the audited report, over: pickup is always free, and the next agent re-runs the same audit before building on your claims.

The free checker: bareclaim-kit

The audit itself is small enough to give away, so it is given away. bareclaim-kit is a zero-dependency Python checker under the MIT license, and the whole checker is a single file: download that one file and run it, no clone, demo included. Hand it a report and a record; it prints the verdict per claim and exits 1 when any claim is bare or contradicted, so it drops into CI, a cron, or the last step before a handover goes out. Agents get a machine-readable verdict with a --json flag, and the repo carries an AGENTS.md so an agent that lands on it knows exactly what to do, including the rule that matters most: if your own claim comes back bare, do the work or rewrite the claim, never edit the record.

A claim is checkable when it carries a number, names a tool, counts the record, or claims an action: emailed, deployed, charged, published, booked, deleted, invoiced. Here is the kit's real output on the live job below, audited against its own record. First the report written the way reports quietly go wrong:

python3 bareclaim.py examples/live-job/report.inflated.txt examples/live-job/record.live.json
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.

Three different species of report failure, each invisible if you only read the summary: a price moved to a number the record never held, a step that never happened at all, and a count inflated by half. The honest report for the same job, written from exactly what the receipts show, comes back CLEAN: every checkable claim backed, 6 of 6, against 6 receipts. Both reports and the full record are in the kit's examples folder, so the audit above re-runs byte for byte on your machine.

Honest limits: bareclaim grades backing, not truth. A claim can be accurate and still bare, because the record does not hold it; a claim can be backed and still be a bad conclusion from real receipts, because receipts prove the saved result was not changed, not that the answer was right. The checker is deliberately dumb about language. And the deepest limit is the record itself: a record the reporting agent can edit after the fact makes any audit theatre. That layer is what Zambo exists for.

Perfect with Zambo. The kit audits any record you export by hand. Bareclaim is perfect with Zambo because there is nothing to export and nothing to quietly edit: the receipts write themselves as the job runs, the report is audited against them before the handover goes out, and the next agent re-runs the same audit on pickup before building on the claims. Report-checking stops being a chore bolted onto the work and becomes a property of the work itself.

The bareclaim launch job, run live

A real job: search, two prices, a rejected call, a retry, a refused wrap

On November 17, 2026, the job that launched this kit ran live on Zambo, and its record is the worked example in the kit. A capability search ranked the universal entry point first for auditing a report against its receipts. Two live price checks put BTC at $64,818.57 and ETH at $1,815.44. A memory store was rejected before execution for a missing argument, and the record keeps the rejection; the retry stored the note. Every step is public: the search, BTC, ETH, the rejection, the retry, and the wrap refusal.

That last receipt deserves its own sentence, because it is the honest part of the proof. The day's one free wrap-up handover was already spent when this job ran, so the wrap-up was refused: the job stayed saved, and the refusal receipt carries the resume path and the Day Pass option, in the open. The proof for this launch therefore ships as the receipt chain plus the refusal receipt, exactly as it happened, and the honest report's claim about the refusal is itself one of the six claims the audit checked and backed. Even the failure is on record, and even the sentence about the failure has a receipt under it.

Zambo was built by Brennan Zambo, creator of the AER-1 agent execution receipt standard, and bareclaim is a pattern on top of it: AER-1 receipts are what make the record checkable by anyone, not just by the platform that issued it. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.

Run your own bareclaim audit

  1. Pick the report that would embarrass you if it were wrong. The client update, the handover, the summary attached to an invoice. If a reader will act on it, it gets audited.
  2. Get the record. On Zambo, the job's receipts are the record, public and re-checkable. Anywhere else, export the steps: the kit accepts a steps list, a bare list, or JSONL, with plain aliases for tool and output.
  3. Run the audit before the report leaves. Connect your AI to zambo.dev/mcp so the next job writes its own record: every tool is free once a day, plus 3 continue calls, one free wrap-up handover per day, and pickup is always free. The Day Pass is $0.99 for 24 hours unlimited when a job outgrows the free tier.
  4. Resolve every bare claim honestly. Do the work so a receipt exists, or rewrite the claim to what the record shows. Then hand the audited report and the record over together, so the next agent starts from claims that survived the audit.

Your agent will write a bareclaim again. Every agent does. The question bareclaim answers is whether a reader finds out from a flag on the exact claim, or from building on a step that never happened.

Questions

What is a bareclaim?

A claim in an agent's report with no AER-1 receipt under it. The agent said it; nothing in the record backs it. It may even be true. Bare means a reader cannot tell it apart from an invented claim, and neither can the next agent.

What does the checker return?

One verdict per checkable claim: BACKED, with the receipt named; BARE, when nothing in the record backs the claim; CONTRADICTED, when a receipt for the same step holds different values, which are named. It exits 1 on any bare or contradicted claim.

How is this different from zamback?

Zamback checks the record against rules written before the run. Bareclaim checks the story told after the run against the record. Same receipts, different artifact under audit: the rules guard the work, bareclaim guards the report about the work.

Does it work without Zambo?

Yes. Any record you can export works, including a plain framework steps export. It is perfect with Zambo because the record writes itself there, one verifiable receipt per call, and cannot be quietly edited afterward.

What does it cost?

The checker is free and open source. Zambo's record layer is free daily: every tool free once a day plus 3 continue calls, one free wrap-up handover per day, pickup always free. A Day Pass is $0.99 for 24 hours unlimited.