Identity control plane
Federate your workforce from any OIDC, SAML, or GitHub IdP, and give every AI agent a real, owned identity instead of a shared key. Every token is short-lived, scoped, audience-bound, and verified offline — and revocable in seconds.
Open beta — free, no invite. Sign in with any Google account (or your org's OIDC / SAML / GitHub IdP), create a workspace, and mint agents — every agent is owned by you, the human root of authority. Your agents can fan out scoped sub-agents under that same authority via delegation. Building for a whole organization? Request a dedicated tenant.
Why Ekam
AI agents today authenticate with long-lived API keys — unscoped, unattributable, and impossible to revoke cleanly. Meanwhile your people are spread across identity providers, and nothing links a human to the agents acting on their behalf. Ekam is one control plane for both: humans federate in from your existing IdP; agents are first-class, blueprinted identities owned by a human and bounded by delegation. Every token is short-lived, audience-bound, and instantly revocable — and everything rolls up to one canonical Person, so a data-subject access or erasure request reaches a person'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, killable.
Federate any IdP (OIDC / SAML / GitHub), enforce least-privilege with JIT elevation, and cut access instantly with a kill-switch + CAEP push.
DPDP-native by design: one canonical Person above every account and agent, so access & erasure act on the whole person, not a fragment.
Verify tokens offline against the JWKS, map the principal to a budget, and meter & bill the owner — no call to Ekam 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 — no waiting to 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 & 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 → budget → bill 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 → 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, the broker mints a single-use token carrying the approval claim. Separation of duties enforced.
SCIM 2.0 from your HR/IdP → a policy maps attributes to claims → a signed webhook 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 AS.
Federated sign-in → 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 → one governed Ekam token, attenuated by blueprint; the upstream identity rides along.
Sign in → 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/entities — so DPDP access & 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.