AI agent identity you can verify and revoke
AI agents call APIs, hold access and act on their own. ComputeID gives each one an AgentPassport: a signed identity record with explicit capabilities that any service can verify, and that its owner can suspend or revoke.
AgentPassport in six facts
- What it is
- A signed identity record for one AI agent: name, organization, description and a list of capabilities.
- Signatures
- RSA-2048 (RSA-SHA256) and ML-DSA-65 (FIPS 204) over the same canonical payload, with per-passport keys that are not retained. Both are reported on verification.
- Verification
- Public endpoint, no API key. Returns status, signature results, capabilities and a CA-signed receipt that expires after 5 minutes.
- Revocation
- Terminal and idempotent. Suspension is reversible. Webhooks announce each change.
- Audit
- Passport issuance, capability checks and logged agent actions are recorded.
- Integrate
- REST API, the Python SDK (
computeid-sdk) and an MCP server (computeid-mcp).
What is AI agent identity?
AI agent identity is a durable, verifiable record of which agent is acting, who it belongs to and what it is allowed to do, that another system can check before it trusts a request.
It answers three questions a service has to ask when software, not a person, is on the other end of a call: is this a known agent, is it still in good standing, and is this action within what it was granted.
ComputeID implements this as the AgentPassport, the first layer of its trust stack. The Trust Score and Trust Decision layers build on it; see the trust engine on the homepage.
Shared keys do not describe an agent
No per-agent identity
When many agents share one API key or service account, a service cannot tell which agent made a call or hold one agent to account.
Permissions are implicit
Access is whatever the key allows. There is no explicit, per-agent statement of what the agent may do that a third party can read.
No per-agent off switch
Cutting off one misbehaving agent means rotating a credential that other agents also use, or finding every place it was copied.
Claims cannot be checked
Another organization has no way to independently confirm an agent's identity or standing without trusting a self-reported header.
Issue, sign, verify
Issue a passport for each agent
Call
POST /v1/agents/registerwith aname, an optionalorganizationanddescription, and a list ofcapabilities. Capabilities are plain strings you define, such asread:invoicesorwrite:refunds. The passport is bound to your account and counts against your passport allowance.The payload is signed twice
The passport's fields are serialized as canonical JSON (keys in alphabetical order, so the signed bytes are reproducible) and signed with an RSA-2048 key (RSA-SHA256) and with ML-DSA-65, the NIST FIPS 204 post-quantum scheme. The same payload carries both signatures, so a verifier can check the classical and the post-quantum one independently. The key pairs are generated for each passport at issue and the private keys are not retained, so the signatures seal the record. They do not give the agent a key to prove itself with.
Anyone can verify it
GET /v1/agents/{id}/verifyneeds no API key. The response reports the passport'sstatus(active,suspended,revokedorinvalid), the result of each signature check, the capabilities, the public keys and the signed payload. A passport with a missing or invalid RSA or ML-DSA signature is reported asinvalid, notactive. The answer comes from the ComputeID registry, which is the source of truth for status.Take a signed receipt with you
Each verification also returns a
verification_receipt: a small JSON document signed by the ComputeID certificate authority (RSA-SHA256) that records the status and both signature results, with akey_idand an expiry 5 minutes after issue. The CA certificate is published at/v1/ca/cert, so a relying party can check a receipt without calling ComputeID again.
What the signatures establish, and what they do not
Established
- The passport record was issued by ComputeID and carries intact RSA-2048 and ML-DSA-65 signatures over its canonical payload.
- Its current standing (active, suspended, revoked or invalid) as held by the registry.
- A short-lived receipt, signed by the ComputeID CA, that you can check against the published certificate.
Not established
- That the caller is the agent. The agent holds no key. A passport ID names an agent; it is not proof of who presents it.
- Anything offline from the passport alone. The passport's keys sign its own payload, so trust rests on the registry's answer and the CA-signed receipt, not on the passport by itself.
Say exactly what an agent may do
Every capability is an explicit string listed in a specific passport. A capability not listed in the passport is not granted by that passport. Actual access enforcement depends on the integrating service checking the capability and applying its own authorization controls.
- Check one capability.
GET /v1/agents/{id}/capabilities/{name}returnsgranted: truewith a signed capability receipt (valid for 5 minutes), orgranted: falsewith a reason:capability_not_found,passport_suspendedorpassport_revoked. The match is exact. - Gate your code on it. In the Python SDK,
passport.check_capability("web_browse")makes that call, so a function can refuse to run when the capability is missing. - Every check is recorded with the requesting account, so the owner can see who asked about their agent.
The Trust Score and Trust Decision layers can score an agent in context and return one of six decisions: allow, allow with monitoring, restrict, quarantine, deny or revoke. The integrating service decides whether and how to apply a decision.
Suspend, reinstate or revoke one agent
An agent's passport can be suspended or revoked on its own, without touching any other agent or credential. Services that check the passport then see its new status.
POST /v1/agents/{id}/suspendandPOST /v1/agents/{id}/reinstateare reversible.DELETE /v1/agents/{id}/revokeis terminal and idempotent. Calling it again returns the stored revocation time and sends no second webhook.- After a revoke, verification reports
status: "revoked"withrevoked_at, capability checks returnpassport_revoked, and the Trust Decision returns REVOKE. - Passport events (
passport.suspended,passport.reinstated,passport.revoked) are sent to your registered webhooks.
Revocation takes effect only where the passport is checked. See the limits below.
A record of what the agent did
Issuing a passport writes a PASSPORT_ISSUED audit entry. The owning account can log an agent's actions with POST /v1/agents/{id}/actions (API key required), and GET /v1/agents/{id}/activity-summary returns the logged actions together with how many were within the agent's granted capabilities and how many were not.
The audit data supports record-keeping for compliance work. It is a data summary, not a certification.
Issue, verify, check and revoke
# Anyone can run this with a passport ID
curl https://api.aicomputeid.com/v1/agents/<passport_id>/verify
# Response, abridged. Values are placeholders.
{
"passport_id": "<uuid>",
"name": "ResearchAgent",
"organization": "Example Corp",
"status": "active",
"signature_valid": true,
"pq_signature_valid": true,
"signatures": [
{"algorithm": "RSA-SHA256", "valid": true},
{"algorithm": "ML-DSA-65", "valid": true}
],
"capabilities": ["read", "web_browse"],
"verification_receipt": { /* CA-signed, expires in 5 minutes */ }
}from computeid import ComputeIDClient, AgentPassport
client = ComputeIDClient(api_key="your-api-key")
# Issue a passport with explicit capabilities
passport = AgentPassport.issue(
client, "ResearchAgent",
organization="Example Corp",
capabilities=["read", "web_browse"],
)
# Check standing and one capability before giving access
if passport.is_trusted() and passport.check_capability("web_browse")["granted"]:
run_your_agent(passport=passport)
# Record an action, then revoke if something looks wrong
passport.log_action("web_search", details={"query": "market research"}, outcome="success")
passport.revoke(reason="Unexpected behaviour detected")# API key required
curl -X DELETE https://api.aicomputeid.com/v1/agents/<passport_id>/revoke \
-H "X-API-Key: $COMPUTEID_API_KEY"Response fields are abridged and the names and values shown are placeholders. The SDK calls above make real requests to the ComputeID API.
What this does and does not cover
Read this before you rely on it
- Revocation depends on checking. A passport is revoked in ComputeID's registry. A service that never verifies the passport, or that caches a result, will not see the change until it checks again. Receipts expire after 5 minutes.
- Revocation does not undo completed work. A request that has already completed is not reversed, and revoking a passport does not reach into another system's own state.
- A passport ID identifies an agent; it does not prove who is presenting it. The agent holds no key, so a valid passport shows that the record is genuine and in good standing, not that the caller controls a private key. Do not treat possession of an ID as proof of identity.
- Not a certification. ComputeID does not hold a SOC 2 report today. Verification receipts and audit data are evidence, not an attestation of compliance.
Questions about AI agent identity
What is an AI agent identity?
An AI agent identity is a durable, verifiable record of which agent is acting, which organization it belongs to and what it is allowed to do, so that another system can check it before trusting a request. In ComputeID this record is an AgentPassport.
How is an AgentPassport different from an API key?
A shared API key shows that someone holds the key. An AgentPassport belongs to one agent, lists that agent's capabilities explicitly, carries signatures that can be re-verified, and can be suspended or revoked without affecting any other agent.
Can anyone verify a passport?
Yes. Verifying a passport by its ID needs no API key, so a partner or downstream service can check an agent's standing, signatures and capabilities. Issuing, revoking and checking capabilities require an API key. Share IDs deliberately: an ID names an agent and is not proof that the caller is that agent.
Does the agent hold a private key?
No. ComputeID generates a key pair for each passport when it is issued, signs the passport with it and does not retain the private keys. The signatures seal the passport record; they do not give the agent a key to prove itself with. Authority comes from the ComputeID registry, which reports current status, and from CA-signed receipts.
What happens when a passport is revoked?
Revocation is terminal. The next verification reports the passport as revoked, capability checks return granted: false with the reason passport_revoked, and the Trust Decision returns REVOKE. Revocation takes effect wherever the passport is checked, so a system that never checks will not see it.
Does ComputeID use post-quantum signatures?
Yes, alongside classical ones. Each AgentPassport is signed with RSA-2048 (RSA-SHA256) and with ML-DSA-65, the NIST FIPS 204 post-quantum signature scheme, over the same canonical payload. Verification reports both results.
Does ComputeID hold a SOC 2 report?
No. ComputeID does not hold a SOC 2 report today. Passport verification and the audit trail produce evidence about agent identity and actions; they are not a certification.
See AgentPassports on your agents
Book a short call and we will walk through issuing, verifying and revoking a passport against your own environment.