Registry is live

The identity layer for AI agents

Open protocol and registry for agent identity. Create an account, register an agent with a public key, then mint a signed Agent Identity Token.

Sign up with Google, an email magic link, or email and password. Minted tokens are ES256 JWTs (typ: AIT+jwt).

A service needs to know which agent called it

OAuth covers user-to-app delegation. OpenID Connect covers user identity. AgentIDP covers agent-to-service identity. The token names the calling agent and the owner behind it, plus the granted capabilities.

Which agent is this?

A raw API key does not name the agent. An Agent Identity Token is a signed JWT. Cache the JWKS and verify locally.

Who is accountable?

Each token carries an owner id, owner type, display name, and verification level, so a service can see who is accountable for the agent.

What can it do?

Agents declare capabilities at registration. Token exchange only grants a subset of those scopes, plus a required audience for the target service.

From an account to a token a service can check

The hosted registry is registry.agentidp.dev. Token exchange needs the owner API key and a proof JWT signed by the agent's registered key. Services check minted tokens against the published public keys.

Register an agent

Sign up, then create an agent with a name and declared capabilities. The registry issues a globally unique agent_id.

Register the agent's public key

Generate an ES256 or EdDSA keypair on the agent. Send the public JWK at create (POST /api/v1/agents) or rotate it later (PUT /api/v1/agents/{id}/public-key). Keep the private key on the agent. The registry never stores it.

Create an owner API key

Create an API key in the dashboard. It is shown once. Send it as a Bearer token on registry API calls. Token exchange also needs the proof JWT from step 04.

Sign a proof JWT, then exchange

Sign a JWT with the agent private key (typ: AIT-POP+jwt, unique jti, max 300 seconds). iss and sub are the agent_id. aud is this host's /api/v1/tokens/exchange URL. POST agent_id, aud, and proof to that endpoint. Optional scopes must be a subset of the agent's capabilities. Optional delegation_chain hops are signed (typ: AIT-DLG+jwt) and can only narrow. Default lifetime is one hour. Maximum is 24 hours.

Verify against the JWKS

Fetch the public key set and check the signature, typ, expiry, audience, and cnf.jkt. Agent status is active, revoked, or suspended.

POST /api/v1/tokens/exchange
# Owner API key authenticates the owner.
# proof is a JWT signed by the agent private key:
#   typ AIT-POP+jwt, alg ES256 or EdDSA
#   iss = sub = agent_id
#   aud = https://registry.agentidp.dev/api/v1/tokens/exchange
#   unique jti, exp - iat <= 300 seconds
curl -X POST https://registry.agentidp.dev/api/v1/tokens/exchange \
  -H "Authorization: Bearer $AGENTIDP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "ag_7xK9m2nP4qRtL8",
    "aud": "https://api.example.com",
    "proof": "$PROOF"
  }'
response.json
{
  "token":       "eyJhbGciOiJFUzI1NiIsInR5cCI6IkFJVCtqd3QiLCJraWQiOiIuLi4ifQ...",
  "token_type":  "AIT+jwt",
  "token_id":    "ait_...",
  "expires_at":  "2026-11-18T18:00:00.000Z",
  "agent_id":    "ag_7xK9m2nP4qRtL8",
  "kid":         "agentidp-..."
}

Claims the registry puts on the JWT

Example payload. Dummy ids. Live tokens also include iat, exp, jti, sub (same as agent_id), and cnf.jkt (SHA-256 thumbprint of the agent's public JWK). verification_level is 0 to 3: unverified, email, domain, organisation.

ait-payload.json
{
  "agent_id":           "ag_7xK9m2nP4qRtL8",
  "agent_name":         "AcmeBookingAgent",
  "owner_id":           "own_T1mR4xBq9",
  "owner_type":         "org",
  "verification_level": 1,
  "capabilities":       ["form:submit", "calendar:read"],
  "iss":                "https://registry.agentidp.dev",
  "aud":                "https://api.example.com",
  "cnf":                { "jkt": "NzbLsXh8uDCcd-6MNwXF4W_7noWXFZAfHkxZsRGC9Xs" }
}

Check the token, then decide

The registry publishes signing keys. Use them to verify registry-issued tokens. Public agent lookup is on the same host.

Public keys

GET /.well-known/jwks.json. Algorithm is ES256. Header typ is AIT+jwt. Minted tokens carry cnf.jkt, the SHA-256 thumbprint of the agent's public JWK.

Agent status

GET /api/v1/agents/{agent_id}/status returns active, revoked, or suspended.

Public lookup

GET /api/v1/agents/{agent_id} for the public record, including owner fields when the registry returns them.

Open spec

The protocol text is Apache 2.0 on GitHub. The hosted registry implements token exchange under /api/v1/.

The registry is open

Create an account, register an agent and its public key, then mint tokens. The spec stays public on GitHub.