Most agent identity schemes verify a key. BAID, a framework described in a paper posted to arXiv in December, argues that's not enough — a stolen or forged key says nothing about whether the code running under that key is the code it claims to be, or whether a human operator actually authorized the action. The paper frames the problem as a dilemma: autonomous AI agents lack traceable accountability mechanisms, creating a fundamental dilemma where systems must either operate as "downgraded tools" or risk real-world abuse. The authors trace this to a specific gap: traditional key-based authentication, which guarantees neither the operator's physical identity nor the agent's code integrity. Their answer combines three mechanisms that are usually treated separately. BAID integrates three orthogonal mechanisms: local binding via biometric authentication, decentralized on-chain identity management, and a novel zkVM-based Code-Level Authentication protocol. The zkVM piece is the unusual part — instead of just signing an output, the system generates a recursive proof over the program binary itself, so by leveraging recursive proofs to treat the program binary as the identity, this protocol provides cryptographic guarantees for operator identity, agent configuration integrity, and complete execution provenance, thereby effectively preventing unauthorized operation and code substitution. Practically, this means an agent's identity claim bundles three separate things a verifier can check independently: that a specific human authorized this session (biometric binding), that the on-chain record of who owns this agent hasn't been tampered with, and that the exact code that ran matches the code that was supposed to run — not a patched or substituted version. That third piece is the one existing agent-identity proposals mostly skip. A signed key tells you an agent with a given identifier made a call; it says nothing about whether that agent's code was quietly modified between deployment and execution. The paper also touches on the discovery layer in passing, describing a scenario where an agent has to find a counterparty through a secure directory system. Without trusted discovery, Agent A risks connecting to fraud — a reminder that identity and discovery infrastructure are coupled problems, not sequential ones. The authors report a working prototype: we implement and evaluate a complete prototype system, demonstrating the practical feasibility of blockchain-based identity management and zkVM-based authentication protocol. Whether zkVM-based code attestation is cheap enough to run per-call, rather than per-deployment, is the open question the paper's benchmarks will need to answer for anyone weighing this against lighter-weight identity schemes already circulating.