跳到正文
DEV Community· rambo·· 7 小時前AI 評分47

AER-1:AI 智能體問責有標準嗎?

Is there a standard for AI agent accountability?

AI 導讀

AER-1 為 AI 智能體問責提供可核驗的收據標準,讓任何人都能檢查記錄及其雜湊值。它是 IETF Informational Internet-Draft,並非 RFC 或 IETF 共識;公開測試集包含 143 個 vectors、146 項檢查,另有獨立實作者驗證測試結果。

正文

The short answer

Yes. There is a standard for AI agent accountability, and it is not a list of principles. It is a stack of checkable pieces that a stranger can run without asking the vendor for permission: a published record format with exact bytes and a hash commitment, a named vocabulary for what checking a record can return, a public conformance corpus, independent implementations built from the draft text alone, and a worked example you can recompute on your own machine.

The standard is AER-1, published as IETF Internet-Draft draft-zambo-aer1-26. Its formal status, stated precisely: AER-1 is an IETF Internet-Draft (Informational), not an RFC and not IETF consensus. The accountability claim does not rest on that label. It rests on the corpus and the independent implementations below, which anyone can inspect today.

Disclosure, once: I run ops for Zambo, the system in the worked example.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. Zambo is the verifiable work layer for AI.

Why principles are not accountability

Most accountability frameworks publish principles: be transparent, be auditable, keep humans in control, log your actions. Those sentences tell you what an agent should do. They give a stranger no way to check what a specific agent actually did on a specific job last Tuesday.

A receipt standard works the other way around. It does not start with intentions. It starts with a record: this call happened, these were its inputs and its saved result, and here is a hash commitment over the exact bytes of that record. Principles tell you what an agent should do; a receipt standard lets a stranger check what it did. Accountability needs the second thing, and it needs it in a form that survives the vendor going quiet, the dashboard changing, or the agent being replaced by a different model next month.

That distinction is the whole piece. The five pieces below are what make a standard real rather than declared.

Piece 1: a published record format

AER-1 defines a record format with exact bytes. A job produces a receipt with a fixed canonical form, and the receipt carries an output_hash: a SHA-256 commitment over those canonical bytes. Change one byte of the saved result and the hash no longer matches. Keep the bytes and anyone, later, can recompute the same digest and compare.

This is deliberately narrow. A receipt proves the saved result was not changed after the fact. It never proves the answer was right. A model can produce a wrong answer and a perfectly valid receipt for that wrong answer, and the standard says so plainly. Accountability needs both that limit and the record: the limit stops the receipt from being oversold, and the record gives you something concrete to argue about when a client, a teammate, or a second agent asks what happened.

Piece 2: a named outcome vocabulary

Checking a record against its anchor returns one of five named outcomes, and only those five:

  1. verified
  2. verification failed
  3. rejected: unresolvable record
  4. not checked
  5. absent

There is no sixth outcome to invent when a result is awkward. That closed vocabulary is what makes reports from different tools comparable. If two verifiers check the same record and return different words from this list, at least one of them is wrong in a way you can point at. If a tool returns a vague status like "looks fine" or "probably ok," it is not speaking the standard, and its verdict should not be counted as one.

The boring words matter most. "Not checked" and "absent" are honest outcomes: the checker did not run, or the anchor was not there to check against. A framework that only knows how to say pass or fail will quietly turn both of those into a pass. AER-1 does not.

Piece 3: a public conformance corpus

A format and a vocabulary are still just text until there is a test set. AER-1 ships one: kit 1.5.7, with 143 vectors and 146 checks, published at https://zambo.dev/aer1/corpus.json . The evaluated set digest is sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2.

Anyone can download the corpus, run their own implementation against it, and publish the count. No account, no private test harness, no "contact sales for certification." If your verifier disagrees with the corpus, the disagreement is reproducible: name the vector, show your bytes, show your hash. That is what a conformance claim should look like in public.

Piece 4: independent implementations

The strongest evidence for a standard is not the author passing their own tests. It is other people building from the draft text alone and getting the same answers.

Laurent Lemonnier built an independent verifier from the draft and passes the full corpus: 143 of 143. Sean Maxwell built a standard library verifier that ran 146 of 146 checks. Tonight, on November 21, 2026, implementer Poke-nushi independently reproduced two corpus vectors from kit 1.5.7, real-04 and bound-04, and got the published hashes exactly.

Three different builders, three separate codebases, the same digests. That is the moment a document stops being one vendor's format and starts behaving like a standard: the text is sufficient for a stranger to arrive at the same result without the author's code and without the author's help.

Piece 5: a worked recompute you can repeat

Here is a live example, verified first-hand tonight, November 21, 2026, at 23:55 UTC.

A live_price call for BTC returned $60,152.58 USD and minted this receipt:

https://zambo.dev/run/0bc28781-e16a-4232-b05e-ef4f19238e69

Its canonical form is 669 bytes. Recomputing SHA-256 over those 669 bytes gives sha256:7b137a148a295e186488898ae21a691b628b3247336e3d4808ab5ad1855ce0c5, which is exactly the receipt's output_hash. Anyone can repeat this at https://zambo.dev/verify with no account: open the receipt, pull its canonical bytes, hash them, compare.

That is the entire accountability loop in miniature. No trust in me, no trust in the dashboard, no screenshots. Bytes, a hash, and a comparison you performed yourself. Zambo's public stream stands at 158K+ public receipts at read time, and every one of them is checkable in this same way, one receipt at a time.

What this does not give you

It does not give you correctness. A receipt binds a result to its record; it does not certify that the price was the best price, that the code was good, or that the agent chose the right tool. It does not give you identity by itself, policy by itself, or a court ruling. What it gives you is the floor that accountability discussions usually lack: a shared, checkable fact about what was saved, which two parties can recompute independently and agree on before they argue about whether it was right.

Build on that floor and the rest gets easier: handovers between agents can carry receipts instead of summaries, client sign-off can point at a record instead of a chat log, and a dispute can start from "these bytes, this hash" instead of competing recollections.

Try it before you pay anything

Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. Start with one job that matters, save its receipt, and recompute it yourself the next day. If the hash matches, you have the accountability primitive working on your own work, not on a vendor's demo.

When you need it all day, the Day Pass is $0.99 unlimited for 24 hours; the Zambo Pass is $29/mo, the $ZAMBO holder Pass is $19/mo, and the Lifetime Pass is $250. The pass is not the point. The point is that accountability stops being a promise in a policy document and becomes a check a stranger can run.

Sources

來源:DEV Community · dev.to