Introducing AgentID: Sign in with AgentID

What is AgentID

AgentID is an OpenID Connect provider from AgentMail that lets AI agents sign into apps with their own verified email identity. Every sign-in returns the agent's address and, for registered clients, the email of the human who owns it. It is free for apps to add and works as a custom provider in Clerk, Supabase, Auth0, and Better Auth.

It ships today as a "Sign in with AgentID" button, the same shape as "Sign in with Google", built for agents.

The problem we kept seeing

AgentMail gives agents email inboxes, which means we sit close to how agents actually behave on the web. The pattern we kept seeing: agents do not have identities, so they borrow their humans'. An agent signs up for a tool as its owner, reads the verification code out of an inbox, and completes 2FA. The app sees an ordinary login.

Then the pattern breaks something. A huge software company reached out to us after observing roughly 1,500 signups from AgentMail domains over a short window, with no way to tell whether that was one person spinning up agents or 1,500 real users. Nothing in their identity stack could answer the question, because nothing in anyone's identity stack can. The web assumes a person behind every login.

Apps in this position cannot enforce per-human limits, cannot treat agent traffic differently from human traffic, and cannot say who is accountable for an account. Owners are stuck lending out entire accounts. Agents get caught in bot detection for lack of a way to disclose what they are.

What AgentID does

AgentID gives the agent its own identity and gives the app the missing information.

For the agent, an AgentID is anchored to its AgentMail inbox: a real email address, so it already works almost anywhere. The agent holds its own signing credential, which never leaves it. Every sign-in is a fresh one-time signature. No password or reusable secret ever reaches the app, and revoking the credential stops that agent from signing in.

For the app, every sign-in returns a signed id_token with a stable subject (same agent, same sub, every time) and the agent's inbox address, verified live when the token is minted. Because the sign-in arrived through AgentID, the app knows it is an agent, and can set policy accordingly.

Apps that want the accountability layer register a client. Registration is one RFC 7591 call authenticated with an AgentMail API key, and it unlocks the profile, owner_profile, and owner_email scopes plus an org claim for organization allowlisting. Owner email is served from the userinfo endpoint after an authenticated call, not embedded in the id_token where it would leak into logs. And when an agent has not granted owner visibility, the sign-in fails with a 403 instead of quietly returning a token without the claim. If your app requires owner_email, you will have it for every agent that gets through.

That one field turns the signup mystery into a query. Fifteen hundred signups resolve to some number of owner emails, and that number is your real user count. Per-human limits work again, KYC pass-through has a real identity to pass, and agent traffic can be rate-limited on its own terms.

What agents get

An agent with an AgentID can sign up for an app on its own. It does not borrow its owner's credentials, and it does not wait for a human to finish a flow on its behalf. The sign-in is the agent's own, start to finish.

Because the identity is an AgentMail address, the agent also receives its own mail. Onboarding emails, receipts, product updates, and support threads arrive in the agent's inbox rather than its owner's, and the app can email the agent the way it emails any other user.

Discovery is the piece we are building next. AgentMail is adding a marketplace inside its console and API where agents find apps that accept AgentID and sign up from there. That work is in progress rather than shipped, and it is the reason the identity and the inbox are the same object.

Standard OIDC, minutes to add

AgentID is a standard OpenID Connect provider, not a custom protocol. Discovery lives at the well-known configuration URL, tokens are signed with ES256 against a published JWKS, and PKCE (S256) is required on every flow. If your app already accepts Google sign-in, your stack already knows how to accept AgentID.

There is a no-registration tier: any app can accept sign-ins using a client_id that is simply a URL it controls, with the openid and email scopes. For platform users, Clerk, Supabase, Auth0, and Better Auth all support AgentID through their custom-provider options; on most of them it is dashboard configuration rather than code, and Better Auth's generic OAuth plugin needs no registration at all.

AgentID is free for apps to add. No usage pricing, no per-sign-in fees.

A note on what verification means here. The email claim is not a stored attribute echoed back from a database; the address is verified live at the moment the token is minted. Combined with credential revocation, that gives owners a real off switch: revoke the credential and the agent stops signing in, everywhere the button appears.

Why we built it

Every agent has a human behind it. We think identity infrastructure should carry that fact rather than hide it, because accountability is what lets apps say yes to agents instead of blocking them. The longer version of that argument is in our manifesto: Every Agent Has a Human.

Get started

For apps

Add AgentID as a custom OIDC provider with two values: issuer https://auth.agentid.com and your client_id. Register a client when you need the owner scopes. Integration guides for Clerk, Supabase, Auth0, Better Auth, and Auth.js are in the AgentID docs.

For agents

An AgentID comes with an AgentMail inbox: the address is the identity. Create one at agentmail.to.

We would rather agents be welcomed than tolerated.