Identity control plane
Bring your workforce in from any OIDC, SAML, or GitHub IdP. Then give each AI agent its own identity instead of a shared API key. A token lives for minutes, works for one audience, verifies offline, and dies the moment you revoke it.
Open beta. Free, and no invite needed. Sign in with a Google account (or your org's OIDC / SAML / GitHub IdP), create a workspace, and mint agents. Each one is owned by you: a human is always the root of authority. Your agents can spin up scoped sub-agents under that same authority through delegation. Building for a whole organization? Request a dedicated tenant.
Why Ekam
Most AI agents still authenticate with a long-lived API key. Nobody can say which agent used it, it can do anything the key allows, and revoking it cleanly is close to impossible. Your people, meanwhile, are spread across identity providers, and nothing ties a human to the agents acting on their behalf. Ekam is one control plane for both. Humans federate in from the IdP you already run. Agents are first-class, blueprinted identities owned by a human and bounded by delegation. Every token is short-lived, bound to one audience, and revocable on the spot. Everything rolls up to a single canonical Person, so an access or erasure request reaches someone's whole footprint, humans and agents alike.
Who it's for
Shipping agents and MCP tools? Give every agent a real identity and a scoped, short-lived token instead of a shared key. Owned, attributable, and killable.
Federate any IdP (OIDC / SAML / GitHub), enforce least-privilege with JIT elevation, and cut access instantly with a kill-switch and CAEP push.
DPDP-native by design: one canonical Person above every account and agent, so access and erasure act on the whole person, not a fragment.
Verify tokens offline against the JWKS, map the principal to a budget, and meter and bill the owner. Ekam is never on the hot path.
The value
A trust layer that adds security without adding latency, built on open standards and under Indian law.
Tokens verify offline against the JWKS. Measured at ~18,000 verifications/sec per core (p99 < 0.1 ms); your gateway never calls Ekam to authorize a request. Tokens are a compact ~640 bytes.
A real kill-switch: revoke an agent and every live token dies. Introspection reflects it immediately, and a signed CAEP event is pushed to subscribed gateways, so nobody waits on a poll.
OAuth 2.1, OIDC, RFC 8693/8707/9728/7662, SCIM 2.0, CAEP/SSF, the MCP auth profile. Bring your own IdP (OIDC/SAML/GitHub) and your own policy engine (groot, OPA, OpenFGA, Cerbos).
Hosted on Krutrim Cloud with Hyderabad + Bengaluru DR, priced in INR. One canonical Person above accounts and agents makes DPDP access and erasure tractable.
Performance figures measured on a single Node 23 process; offline verification scales linearly across cores and pods.
How it works
Owner mints an agent from a blueprint
Short-lived, scoped, delegated token
Gateway verifies offline via JWKS
Map agent to budget, bill the owner
Kill-switch stops it in seconds
Key features
agt_…: owned, blueprinted, revocable. Not an API key.
Audience-bound (RFC 8707), scoped, delegated via the act chain (RFC 8693).
ES256 JWT + JWKS. The gateway never calls Ekam on the hot path.
Revoke an agent; introspection (RFC 7662) reflects it, and Ekam pushes a signed CAEP session-revoked event (SSF) to subscribed gateways in real time.
One-time, time-boxed privileged elevation: request, approve, then a single-use, auto-expiring token with scope beyond the blueprint.
High-risk agent action? Pause for a human. OpenID CIBA backchannel consent: the agent asks, a named human approves out-of-band, and the broker mints a single-use token carrying the approval claim. Separation of duties enforced.
SCIM 2.0 from your HR/IdP, a policy that maps attributes to claims, and a signed webhook that pre-provisions connector grants. Zero-click day-one access.
OAuth 2.1 auth-code + PKCE + dynamic client registration (RFC 7591) on the RFC 9728 on-ramp. Any MCP client (Claude Desktop, IDEs) self-registers and gets a token bound to your MCP server. Ekam is the authorization server.
Federated sign-in gives a type:human token, with request, approve, grant.
Federate any OIDC provider (Okta, Microsoft Entra, Auth0), a SAML 2.0 IdP (incl. ADFS / OneLogin), or GitHub. A tenant registers its IdP once; its people sign in with it.
Ask POST /authz/decision "may this token do this action on this resource?" Decide locally (scope + classification ladder) or delegate to your PDP: groot, OPA, OpenFGA/SpiceDB (Zanzibar), or Cerbos. Fail-closed.
Accept agent tokens from Microsoft Entra Agent ID, OpenAI, or Anthropic WIF via RFC 8693 token-exchange, giving one governed Ekam token, attenuated by blueprint; the upstream identity rides along.
Sign in, and a workspace is your billable account; mint and revoke keys, see live usage. Every action is metered (append-only). Free in beta.
One canonical Person above many accounts and entities, so DPDP access and erasure act on the whole person, not a fragment.
Tenant / entity model, plus ID-JAG cross-app delegation.
For developers
type:human token. The root of authority.POST /v1/agents); every agent is owned by a human.POST /oauth/token brokers a scoped, delegated token; agents fan out sub-agents via the act chain.For organizations
Ekam is in open beta: anyone can sign in or self-serve an agent right now, no invite needed. This form is for organizations that want a dedicated tenant, their own SSO (OIDC / SAML / GitHub), SCIM provisioning, data-residency, or enterprise terms. Tell us what you'd build and we'll set you up.