Stop trusting the green dashboard. If your AI agent returns a 200 OK status or a self-reported 'success' message, you have not verified the work; you have merely accepted the agent's word for it. In a recent deep dive on DEV.to, Brennan Zambo, creator of the Zambo work layer, dismantles the current state of agent verification, arguing that true proof of agent work must be a record that a stranger can recompute byte for byte without needing an account, a login, or blind trust in the executing system.

The Three Pillars of Verifiable Execution

Zambo defines proof of agent work through three non-negotiable properties that shift verification from internal bookkeeping to external arithmetic. First, the record must be written at the exact moment the work runs by the execution layer itself, not retroactively by the agent describing its own actions. Second, the record must contain the exact result bytes committed under a SHA-256 digest computed over a canonical form. Third, the system must allow anyone to fetch those bytes and recompute the digest independently. If the recomputed hash matches the saved output_hash, the integrity is proven; if it differs by even one character, the record fails loudly.

Why Self-Attestation Is Just Bookkeeping

The industry’s current trend of grading agent self-reports into levels like 'verified-custom' or 'attested-only' is fundamentally flawed because the party being checked controls the record being checked. As Zambo notes, an 'attested-only' rung is just the agent attesting to itself, while a 'verified' rung means the agent’s library is checking its own records against its own rules. This is bookkeeping, not proof. The recomputation test breaks this loop by making the bytes public and the verification a matter of pure arithmetic. The checker needs nothing from the producing system except the record itself, eliminating the trust gap entirely.

A Live Test on the Zambo Network

To demonstrate this, Zambo ran a live price check for BTC at $61,621.38 on November 20, 2026, via the Zambo work layer. The resulting receipt, issued at 09:30:22 GMT, carries a public URL and a specific SHA-256 digest. By fetching the canonical 670 bytes and hashing them, the author produced the digest sha256:1c672475b2ee0d8aa940c28294c089bf1d84beeba9fb282a81a0065014857e42, which matched the saved output_hash exactly. This process took one fetch and one hash, proving that the saved result was unchanged from what the call returned. This same check is available for any of the 152,616 public receipts Zambo has issued, with over 1,100 minted that morning alone.

The AER-1 Standard and Industry Convergence

This verification method is formalized in AER-1, an open Internet-Draft (draft-zambo-aer1-26) on the IETF datatracker. The standard has seen rapid adoption, with five separate systems reorganizing around it on November 19, 2026, including a payments builder deploying a contract to Base Sepolia and an independent implementer passing all 143 conformance vectors. Laurent Lemonnier, who built his verifier from the draft text alone, confirmed that the custody and reliance splits hold in live systems. When other people’s systems begin to bend around a record format, proof stops being a vendor claim and becomes infrastructure.

Key Takeaways

  • Self-reported status codes and internal dashboards are insufficient for verifying AI agent work because the agent controls the narrative.
  • True proof requires a record written by the execution layer at the moment of the call, containing exact result bytes and a SHA-256 digest.
  • Verification must be permissionless: anyone should be able to fetch the bytes and recompute the hash without an account or trust in the provider.
  • The AER-1 standard is gaining traction, with independent implementers and on-chain contracts adopting the format for verifiable execution.
  • A receipt proves integrity (the result wasn't changed), not correctness (the answer was right); stale data will still recompute successfully.

The Bottom Line

Stop letting agents grade their own homework. If you can't independently recompute the hash of the execution record, you don't have proof of work, you have a promise. Zambo's push for AER-1 highlights a critical gap in the current AI agent stack: the lack of cryptographic accountability. By shifting from opaque status levels to transparent, recomputable records, the industry can move toward a model where trust is replaced by verification. This is not just a technical upgrade; it is a fundamental requirement for agents operating in high-stakes environments where 'success' must be mathematically provable, not just declared.