Most agent identity proposals stop at authentication: prove you are who your credential says you are. A newer paper surfacing in the same research thread as last year's zero-trust agentic IAM framework argues that's not enough, because an agent's identity is inseparable from its execution state — and that state changes. The paper notes that existing identity and access management mechanisms assume centralized enrollment, persistent identifiers, and stable execution contexts, assumptions that don't hold for AI agents, whose identities are self-managed, short-lived, and tightly coupled with their execution state and capabilities. The authors identify three specific challenges: supporting self-managed identities for agents that autonomously spawn other agents, enabling authentication under large-scale concurrent interactions, and verifying an agent's dynamic execution state — whether its context and capabilities still hold at the moment of interaction, not just at enrollment. Their answer is AgentDID, described as a decentralized framework for identity authentication and state verification. The framing matters because it reframes the identity problem: a credential issued at agent creation says nothing about whether that agent's current behavioral scope, context, or capability set still matches what was authorized. An agent could hold a perfectly valid DID and verifiable credential while operating well outside the bounds implied by that credential, because its internal state has drifted since issuance. This is a distinct problem from the one the earlier zero-trust IAM framework addressed. That work, which proposed rich agent identities built on DIDs and verifiable credentials plus an Agent Naming Service for discovery, focused on establishing who an agent is and what it's allowed to do at the protocol level. AgentDID is positioned against that work explicitly, building on similar decentralized-identity principles but pushing further into runtime state verification rather than static credential issuance. The distinction between identity-at-issuance and identity-at-runtime is exactly the gap that's been hardest to close in agent security discussions this year. A signed credential is cheap to check. Verifying that the agent presenting it hasn't since been reconfigured, delegated to a sub-agent, or drifted in context is a much harder property to prove, and one that current protocol specs mostly don't attempt. Whether AgentDID's approach to state verification holds up under adversarial testing — rather than just design description — is the open question worth watching.