An AI agent that books a flight on your behalf is presenting itself to the airline as someone authorised to act for you. An agent that pulls a medical record on behalf of a clinician is doing the same. An agent that signs a contract, makes a payment, or coordinates with another agent across organisational boundaries — all of these actions require something that traditional identity systems were not designed for: a portable, machine-readable, cryptographically verifiable identity for a non-human actor.
This is where the self-sovereign identity work that came out of the Web3 / decentralized identity community over the last decade — work we wrote about as self-sovereign identity and its use cases a few years ago — turns out to be exactly the right primitive at exactly the right time.
Why API keys aren’t enough
The default way to give an AI agent access to a system in 2024–2025 has been to issue it an API key or an OAuth token. That works fine for one-to-one integrations inside a single trust boundary. It fails when:
- The agent needs to introduce itself to a system it has no pre-existing relationship with.
- Multiple agents need to coordinate without a central coordinator.
- The downstream system needs to verify which agent took an action, signed by whom, with what authority, six months after the fact.
- Authorisation needs to be revoked, scoped, or delegated independently of the underlying secret.
The self-sovereign identity primitives that fit
Three building blocks from the SSI world map onto the AI agent problem cleanly:
- DIDs (Decentralized Identifiers). A DID is a globally unique identifier the agent (or the entity that operates it) controls without a central registrar. It resolves to a document that exposes the agent’s public keys, service endpoints, and capabilities.
- Verifiable Credentials. Signed claims about the agent — “this agent is operated by Acme Corp”, “this agent is authorised to spend up to $500/day on behalf of user X”, “this agent is HIPAA-cleared for entity Y” — that the agent can present, and any system can verify, without contacting an issuer.
- NFT-style identity tokens. For agents that need a public on-chain identity (reputation systems, agent registries, agent marketplaces), an NFT-style token works as a portable handle. We’ve written about NFTs as a general identity primitive for exactly this reason.
What this enables in practice
- An agent can present credentials to another system the first time they meet, with no prior integration.
- Every action an agent signs has an unambiguous, after-the-fact-verifiable provenance.
- Reputation can attach to the agent identity (or to its operator) and travel with it across contexts.
- Authorisations can be scoped, delegated, and revoked independently of any single host platform.
The open questions
None of this is fully solved as of mid-2025:
- Legal recognition. No major jurisdiction treats an AI agent as a legal person. Liability still flows back to the operator. The SSI machinery makes that traceability cleaner — it doesn’t change the underlying legal frame.
- Key management at machine scale. An agent operating at the speed of a single LLM call may sign thousands of times per second. Key custody, rotation, and revocation need to fit that throughput.
- Standardisation. DIDs and VCs are W3C standards, but the specific schemas for “AI agent identity” are still settling. Expect a year or two of fragmentation before consolidation.
Why this matters for product builders
If you’re building a product that incorporates AI agents — especially in regulated industries — the question of “how does this agent introduce itself” is going to land on your roadmap. Building it on SSI primitives now is significantly cheaper than retrofitting later, and it positions you for the agent-to-agent commerce patterns that are starting to emerge in 2025.
Related from Ethora: Ethora AI Agent SDK — build AI chatbots and agents on top of a messaging substrate with full data ownership.