Is this really that agent?
Five use cases, in order. Each starts with the business story, then shows the technical flow: Oathera Agent Enrollment and Oathera Agent Enforcement on your MCP server, the Oathera Identity Service, and the service itself.
An agent with no identity
Oathera Agent Enforcement refuses the agent, and the console lists it so you can enroll it or reject it.
How Oathera governs an AI agent with no non-human identity
An agent is already calling your tools with a borrowed key and no non-human identity (NHI) of its own. Oathera's gateway refuses it, the console lists it, and you decide whether to enroll it under agentic identity control or reject it. This is the first step of autonomous agent governance: nothing acts until it has a machine-bound identity.
The technical flow
- The agent calls a tool through Oathera Agent Enforcement without an identity token. Oathera Agent Enforcement refuses the call (
invalid_token) on its own, before any call to the Oathera Identity Service or the tool. - Oathera Agent Enforcement writes a deny event to its own audit log.
- Oathera Agent Enforcement reports the refusal to the Oathera console.
- The console lists the unidentified agent, and an administrator enrolls it, which gives it an identity, or rejects it.
An agent with an identity reaches a service
One identity, one approval, and a check on every call.
How Oathera issues machine-bound non-human identity to an AI agent
A new agent gets its own machine-bound non-human identity (NHI), with a named person who answers for it, and every call it makes to a service is checked. Nobody shares a key, and the record shows which agent acted and who approved it, giving you provable agentic identity control from enrollment through every runtime call.
The technical flow
- The agent's anchor key is created on its host and the host is observed. Oathera Agent Enrollment asks the Oathera Identity Service to start enrollment, with the request signed by the anchor key.
- A person, the principal, signs in through your identity provider and approves the agent. The approval page shows the clearance requested for the agent.
- The Oathera Identity Service writes the agent's enrollment record: its anchor key, the principal, its host and what the agent stated about itself. Oathera Agent Enrollment checks the Oathera Identity Service's signed activation.
- The agent asks for an identity token. The Oathera Identity Service compares the host with the enrollment record and issues a token that names a new session key, held only in memory.
- Before each call, the agent signs a single-use operation proof with the session key, over the operation and its arguments. It signs for the sample tools in the MCP bundle, and Oathera Agent Enforcement verifies proofs for any tool you configure.
- Oathera Agent Enforcement checks the token and the proof, then asks the Oathera Identity Service for a signed boundary decision: is the agent still active, and is the person who approved it still active.
- On an allow, Oathera Agent Enforcement sends the service a short, single-use gateway assertion in place of the token.
Impersonation
A token on its own is worth nothing, and a name is not a credential.
How Oathera prevents non-human identity impersonation
Another agent presents this agent's token or name. It is refused, because it can't prove it holds the agent's key. A token on its own is worth nothing to whoever copied it: in the non-human identity space a name is not a credential, and agentic identity control requires proof of possession on every call rather than a bearer secret.
The technical flow
- The other agent sends this agent's identity token to Oathera Agent Enforcement. Oathera Agent Enforcement verifies the operation proof with the session key the token names. The other agent doesn't hold that key, so the proof fails and the call is refused before any call to the Oathera Identity Service.
- Sent as a bearer credential straight to the service, the token is refused.
- A name is not a credential. The Oathera Identity Service finds an agent by the anchor key that signs its token request, and a call that carries only a name has no token, so it is refused as in UC01.
- A captured proof can't be replayed: each proof carries a nonce that is used once.
In the simulator
Three scenarios show this use case: a stolen token sent straight to the service, refused; a replayed proof, refused; and a tampered call, refused. Open the simulator.
Cloning
Copy the agent and the copy is caught at its next token.
How Oathera prevents non-human identity (NHI) cloning
"AI agents can be cloned; identities cannot be." Copy an agent to another machine, code and key together, and the copy is caught at its next token because its machine-bound non-human identity no longer matches its host. Copy an agent and you get the same code with a different agentic fingerprint, so autonomous agent governance holds even when the code itself is duplicated.
The technical flow
- The copy's new host is observed on its machine, and the new host digest goes with its token request.
- The Oathera Identity Service compares the host digest with the enrollment record. With host binding set to enforce, it refuses the token (
403 host_changed). - With host binding set to warn, the default for testing and design partners, it issues the token, marks it with host drift and records a high-severity host-change alert.
- With platform attestation required, the Oathera Identity Service also refuses a host that has no verified attestation bound to the agent's key. Google Cloud is the platform whose attestation reaches verified.
Tokens already issued to the original agent stay valid until they expire, five minutes at most.
An agent tries a service outside its boundary
The call is refused for an unknown operation, an unlisted or unconfigured tool, arguments outside the allow-list, a wrong audience, a service outside the agent's permitted list, too little clearance, or an assertion made for another service.
Enforcing agentic identity governance outside allowed boundaries
An agent reaches for a tool or service it wasn't set up for, and the call is refused. Agentic identity control is not only about who the agent is but what it may do: Oathera enforces autonomous agent governance at the MCP boundary, so an operation, audience, or argument outside the agent's approved boundary never reaches the tool.
The technical flow
- The agent refuses to sign an operation it doesn't know (
invalid_operation). - Oathera Agent Enforcement refuses a tool the server doesn't list (
unknown_tool). With its default-deny setting on, it also refuses any tool you haven't configured (operation_not_configured). - Oathera Agent Enforcement refuses arguments outside a tool's allow-list.
- The identity token names one audience, and the Oathera Identity Service refuses it anywhere else. Its boundary decision also checks the agent's list of permitted services, and refuses an operation that needs more clearance than the agent holds.
- The gateway assertion names one service, and a service refuses an assertion made for another.
Run it in front of one real tool.
Design partners get a dedicated tenant, direct access to the founders, and a say in the roadmap. We ask you to run Oathera in front of one real tool with real agents, and tell us what breaks.