Identity control plane

Every agent gets a name, an owner, and an off switch.

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

Platform & AI teams

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.

Security & IAM teams

Federate any IdP (OIDC / SAML / GitHub), enforce least-privilege with JIT elevation, and cut access instantly with a kill-switch and CAEP push.

Compliance & privacy (DPO)

DPDP-native by design: one canonical Person above every account and agent, so access and erasure act on the whole person, not a fragment.

AI gateways & apps

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.

No hot-path latency

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.

Contain in seconds

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.

Standards-native, no lock-in

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).

India-native & DPDP-ready

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

1

Provision

Owner mints an agent from a blueprint

2

Broker

Short-lived, scoped, delegated token

3

Verify

Gateway verifies offline via JWKS

4

Meter & bill

Map agent to budget, bill the owner

5

Revoke

Kill-switch stops it in seconds

Key features

First-class agent identity

agt_…: owned, blueprinted, revocable. Not an API key.

Token broker

Audience-bound (RFC 8707), scoped, delegated via the act chain (RFC 8693).

Offline verification

ES256 JWT + JWKS. The gateway never calls Ekam on the hot path.

Kill-switch + CAEP push

Revoke an agent; introspection (RFC 7662) reflects it, and Ekam pushes a signed CAEP session-revoked event (SSF) to subscribed gateways in real time.

JIT-PAM

One-time, time-boxed privileged elevation: request, approve, then a single-use, auto-expiring token with scope beyond the blueprint.

Human-in-the-loop (CIBA)

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.

Birthright access

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.

MCP authorization server

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.

Human SSO + IGA

Federated sign-in gives a type:human token, with request, approve, grant.

Bring your own IdP

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.

Per-resource authorization

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.

Federate external agent issuers

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.

Self-service workspaces + metering

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.

Identity graph + DPDP

One canonical Person above many accounts and entities, so DPDP access and erasure act on the whole person, not a fragment.

Multi-tenant + cross-app

Tenant / entity model, plus ID-JAG cross-app delegation.

For developers

Principals

  • Humans: Sign in with Google (or your tenant's OIDC IdP / GitHub) for a type:human token. The root of authority.
  • Create agents: a signed-in human mints agents from a workspace key (POST /v1/agents); every agent is owned by a human.
  • Agents: POST /oauth/token brokers a scoped, delegated token; agents fan out sub-agents via the act chain.
  • For agents: /llms.txt · /llms-full.txt.

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.