Identity · CA
A zkVM Proof for 'The Agent Doing This Is the Agent You Authorized'
A new paper proposes binding AI agent identity to biometrics and on-chain code integrity, aiming at a specific gap: key-based authentication tells you a request carried the right signature, not that the right human and the right code produced it.
The paper's framing is blunt about the stakes. The authors note that autonomous agents currently lack traceable accountability mechanisms, forcing a choice between being "downgraded tools" or risking real-world abuse. Traditional key-based auth, they argue, guarantees neither the operator's physical identity nor the agent's code integrity — so a stolen key or a swapped binary looks identical to a legitimate run from the outside.
Their answer is BAID (Binding Agent ID), which combines three pieces that are usually handled separately: local biometric binding between a human and an agent, decentralized on-chain identity management, and a zkVM-based code-level authentication protocol. The zkVM piece is the more novel contribution — it treats the agent's program binary itself as the identity, using recursive zero-knowledge proofs so an agent can prove it ran specific, unmodified code on behalf of its registered owner, without revealing the code or configuration itself. The stated goal is cryptographic guarantees across three axes at once: operator identity, configuration integrity, and execution provenance, which together are meant to block both unauthorized operation and code substitution attacks.
This is a different bet than most identity proposals circulating right now, which mostly focus on registering an agent's identifier and credentials at setup time. BAID tries to close a longer-running gap: proving, after the fact, that the thing that acted was the thing that was authorized to act, down to the binary level. That matters for accountability disputes — if an agent causes harm, the question isn't just "was it authenticated," it's "was it running the code it was supposed to be running, for the person it was supposed to be serving." A signature alone can't answer that; a zkVM proof over committed code potentially can.
The authors built and evaluated a full prototype, including the identity management smart contracts and the zkVM verification circuits, which puts this past the purely theoretical stage, though it's still a single academic system rather than anything deployed in production agent frameworks. The real test will be whether the proof generation and verification overhead is cheap enough for agents that need to act in real time, and whether any of the major agent protocols currently competing for identity standardization — A2A, MCP extensions, the various DID-based proposals — adopt code-binding as a requirement rather than treating authentication as sufficient on its own.