Your agent doesn’t need an NFT or a DID on a chain to prove who it is. A signed ES256 JWT credential and a published JWKS endpoint let any third party verify an AI agent’s identity offline, with the same public-key cryptography that already secures HTTPS — no wallet, no chain lookup, no gas fee.
Verifiable agent identityis a cryptographically verifiable claim about an AI agent’s identity — established via a signed credential and a published public key — that a third party can confirm without calling back to the issuing platform and without trusting the claimant’s word. The credential itself carries the proof; verification happens locally, offline, against a key the verifier already fetched.
Search “verifiable AI agent identity” and most of what comes back assumes a chain: ERC-8004 agent registries, decentralized identifiers (DIDs), on-chain reputation, NFT-bound credentials. That’s a legitimate design choice — it buys censorship resistance and public, permanent provenance that no single company can revoke. It is not the only choice, and for most production teams it isn’t the first one that solves the actual problem in front of them: can the platform on the other end confirm this agent is who it says it is, right now, without a chain lookup?
VeriSwarm Passport answers that with standards-based, offline public-key verification — ES256-signed JSON Web Tokens (JWTs) and a JWKS endpoint. It’s the same cryptographic primitive underneath OAuth and HTTPS, applied to agent identity instead of web sessions. No chain to sync, no wallet to fund, no smart contract to audit.
The credential lifecycle is four steps, and none of them require a synchronous call back to VeriSwarm after the first key fetch.
The agent authenticates with its agent API key and calls POST /v1/credentials/issue.
VeriSwarm loads the agent’s latest trust snapshot, builds a JWT payload, and signs it with the platform’s ES256 private key (kid: "veriswarm-2026").
The agent includes the signed credential in outbound requests, handshakes, or capability negotiations with other agents or platforms.
The receiving party fetches VeriSwarm’s public key from GET /.well-known/jwks.json and verifies the signature and expiry locally — no API call required after the key is cached.
The full lifecycle, code examples in Python and Node, and the exact claim schema are in Agent Passports: Portable Trust That Follows Your Agent Everywhere.
The JWT uses the ES256 algorithm with a key ID header. Standard claims plus a veriswarmnamespace carry the agent’s live trust posture — not just a static identity assertion.
| Claim | Meaning |
|---|---|
iss | Issuer — always https://api.veriswarm.ai |
sub | Subject — the agent’s unique ID |
iat / exp | Issued-at and expiration — 1-hour TTL |
veriswarm | Dimension scores, composite trust, policy tier, risk band, calibration confidence, verification status, and a link to the agent’s public profile |
Because the identity claim and the behavioral posture travel in the same signed object, a relying party gets both in one verification — the agent’s identity andwhether it’s currently trustworthy enough to hand a task to.
Proving who an agent is answers only one of the two questions that matter for an access decision. The second — is this agent behaving in a way that should keep its access right now— is a separate, continuously-updated question that a static identity credential, blockchain-backed or not, can’t answer on its own. That distinction, and why conflating the two is how production agent governance fails, is the subject of Identity vs. Trust for AI Agents. This page is the how-to for the identity half; that guide is the argument for why identity alone was never going to be enough.
The clearest use case for offline-verifiable identity is agent-to-agent handoff, where there’s no time for a human to review a credential before a task gets delegated. VeriSwarm’s A2A protocol implementation uses exactly this credential model to let one agent evaluate another before trusting it with a task — the mechanics of that are in A2A Protocol Security: Why Agent Cards Aren’t Trust.
No. Blockchain-based agent identity (ERC-8004, decentralized identifiers, on-chain passports) is one valid approach, built for censorship-resistance and on-chain provenance. But most teams don't need a chain lookup to answer "is this the agent it claims to be?" VeriSwarm Passport uses ES256-signed JWTs verified against a published JWKS endpoint — the same public-key cryptography that already secures HTTPS and OAuth, with no wallet, no gas fee, and no chain to sync.
A claim is verifiable when a third party can confirm it without trusting the claimant and without calling back to a central authority for every check. VeriSwarm signs each agent's credential with an ES256 private key; the corresponding public key is published at a JWKS endpoint. Anyone — a partner platform, a marketplace, another agent — can fetch that public key once, cache it, and verify every subsequent credential locally.
Four steps. The agent requests a credential from VeriSwarm using its agent API key. VeriSwarm signs a JWT containing the agent's identity and current trust state with its ES256 private key. The agent carries that JWT in outbound requests or handshakes. The receiving party fetches VeriSwarm's public key from /.well-known/jwks.json, matches the key ID in the JWT header, and verifies the signature offline — no network call to VeriSwarm required after the initial key fetch.
Standard JWT claims — issuer, subject (the agent's ID), issued-at, and a 1-hour expiration — plus a veriswarm namespace carrying the agent's dimension scores, policy tier, risk band, calibration confidence, and verification status. It's not just an identity claim; it's an identity claim with a live behavioral posture attached, which is the part a bare DID or NFT credential doesn't carry.
None — basic ES256 credential issuance, offline verification, and the JWKS endpoint are free and unlimited on every plan, including Free. The underlying trust score embedded in every credential is computed by Gate, which is also free with unlimited event ingestion. Passport's fuller identity product — signed manifests, delegation scopes, and manual identity-verification workflows — ships on the Pro plan and above; the credential itself doesn't require it.
OAuth and machine-identity systems were built for services with stable identifiers and long-lived credentials, verified by calling back to an issuer. Passport credentials are short-lived (1 hour), carry a live behavioral score rather than a static role claim, and are designed to be verified offline by a party that has no prior relationship with VeriSwarm. Use machine identity for your service-to-service tier; use a Passport credential for the agent-to-agent tier above it.
ES256 credential issuance, offline verification, and the public JWKS endpoint are free and unlimited on every plan. Delegation scopes and signed manifests — the fuller Passport product — ship on Pro and above. The trust score in every credential is computed by Gate, which also runs free.