AI agent identity

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.

At a glance

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

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.

The problem

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.

How it works

Issue, sign, verify

  1. Issue a passport for each agent

    Call POST /v1/agents/register with a name, an optional organization and description, and a list of capabilities. Capabilities are plain strings you define, such as read:invoices or write:refunds. The passport is bound to your account and counts against your passport allowance.

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

  3. Anyone can verify it

    GET /v1/agents/{id}/verify needs no API key. The response reports the passport's status (active, suspended, revoked or invalid), 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 as invalid, not active. The answer comes from the ComputeID registry, which is the source of truth for status.

  4. 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 a key_id and 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.

Cryptographic identity

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

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} returns granted: true with a signed capability receipt (valid for 5 minutes), or granted: false with a reason: capability_not_found, passport_suspended or passport_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.

Revocation

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}/suspend and POST /v1/agents/{id}/reinstate are reversible.
  • DELETE /v1/agents/{id}/revoke is terminal and idempotent. Calling it again returns the stored revocation time and sends no second webhook.
  • After a revoke, verification reports status: "revoked" with revoked_at, capability checks return passport_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.

Audit trail

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.

Technical example

Issue, verify, check and revoke

Verify a passport (public, no API key)
# 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 */ }
}
Python SDK (pip install computeid-sdk)
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")
Revoke over REST
# 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.

Scope and limits

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

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.