Open Standard · v1.2.0

The open standard forAgent Identity

Agent identity, credentials, verification, wallet authority, and skills governance behind one open SDK facade.

>resolve("")

01 — Document

Identity and entity kind.

did:oas — a DID method for autonomous agents, designed against W3C DID Core.

did-document.json
{
"@context": "https://www.w3.org/ns/did/v1",
"id": "did:oas:l1fe:agent:z6MkhaX...doK",
"kind": "agent",
"created": "2026-04-09T00:00:00Z",
"verificationMethod": [{
"id": "#key-1",
"type": "Ed25519VerificationKey2020",
"publicKeyMultibase": "z6Mkha...doK"
}],
"authentication": ["#key-1"],
"service": [{
"id": "#agent-api",
"type": "OASEntityService",
"serviceEndpoint": "https://agent.example"
}],
"lineage": {
"humanRootDid": "did:oas:l1fe:hmr:alice",
"creatorDid": "did:oas:l1fe:hmr:alice",
"generation": 1,
"derivationProof": { "type": "AgentLineageProof2025", ... }
}
}
Ln 0, Col 1
0/23 linesbuilding

02 — Lineage

The human root.

Every lineage chain terminates at a human-root keyholder (HMR/MHR). Cryptographic ancestry — not a personhood or Sybil attestation.

Human Root
Derived Roots
Agents
Entities

03 — Verification

7-step verification pipeline.

Every identity passes through the same rigorous process.

Ready
aegis-verify v0.1
01RESOLVE
02SCHEMA
03SIGNATURE
04REVOCATION
05LINEAGE
06LIVENESS
07CONFORMANCE
did:oas:l1fe:agent:z6MkhaX...doK0/7 steps
04 — How it works

You just watched
the whole system.

Agent identity sounds heavy. It is three ideas — a signed document, a chain of custody, and a verification routine — built entirely from primitives your stack already trusts. Here is the same story in developer terms.

format · did:oas URI + identity document

signature · Ed25519, self-signed

registry · none required

An identity is a document, not an account.

Every agent gets a did:oas identifier and an identity document listing its public keys and entity kind. The document is signed by a key it lists, so anyone holding it can check its integrity directly — there is no central registry to query and no account to provision. That is the OAS specification: an open DID-based standard designed against W3C DID Core — not a W3C endorsement, and not a vendor login.

derivation · HKDF-SHA256

proof · AgentLineageProof2025

root · human-root keyholder (HMR / MHR)

Every agent traces back to a human.

Agent keys are derived from their parent's keys with HKDF-SHA256, and every derivation carries a signed lineage proof. Follow the chain upward and you land on a human-root keyholder (HMR / MHR). That proves cryptographic ancestry under the verifier's trust policy — not legal personhood or Sybil resistance, which stay out of band. Authorizing verification uses typed lineage APIs; structural shape checks never grant privilege.

pipeline · 7 checks, in order

signature · constant-time Ed25519

network · no external calls required

Verification is a routine, not a service.

The seven checks you watched — resolve, schema, signature, revocation, lineage, liveness, conformance — run wherever your code runs. The signature check is constant-time Ed25519, and the pipeline is designed to complete without external network calls. Fewer moving parts and fewer round trips: that is where the speed and the security actually come from.

05 — The integration

This is
all it takes.

Not pseudocode — the complete calls. Create OAS identities, authenticate requests, broker Arsenal credentials, require anchored lineage authority, and gate skills from the six-language SDK: TypeScript, Rust, Python, Go, Swift, Kotlin.

The verification pipeline you scrolled through is the .verify() call below. One import gives you the whole stack; every failure returns a named reason instead of a silent pass.

IdentityOAS + anchored lineage
VerificationAEGIS + revocation
CredentialsArsenal ACTs
Governanceskills policy + audit
typescript · complete example@openagentid/sdk · oas-sdk
import { act } from '@openagentid/sdk';

const claims = await act.verify(tokenBytes)
.issuer('arsenal:broker:prod-1')
.forAudience('my-service')
.requireScope('tools:calendar:invoke')
.trustedKeys([brokerPublicKey])
.run();

// verified claims, or a thrown reason:
// forged, expired, wrong-audience, under-scoped
$npm install @openagentid/sdk
06 — The control plane

One facade over the full
agent identity control plane.

OpenAgent ID is not just a DID method. It is the layer where OAS identity, Arsenal capabilities, AEGIS verification, wallet derivation, skills governance, and conformance meet the app developer.

01FacadeOpenAgent SDKOne import for creating agents, authenticating requests, brokering credentials, checking skills policy, and reaching the lower layers when needed.TypeScript and Rust 0.1.0 public facadeOpenAgent.createAgent / OpenAgent.authenticateRuntime escape hatches for OAS, Arsenal, and AEGIS02IdentityOASThe did:oas identity layer: entity kinds, DID documents, local signatures, lineage proofs, and Sigil-backed authority verification.Portable DID and document verificationHuman, collective, org, agent, tool, skill, model, dataset, and service identitiesPrivileged authority fails closed without finalized Sigil lineage03VerificationAEGISThe request-time decision layer for signature validity, lineage, revocation, liveness, trust tiers, delegated authority, and policy.Anonymous, identified, and sovereign launch tiersFresh revocation checks even when verification is cachedPolicy for rate, time, spend, approval, and trust requirements04CapabilitiesArsenalThe ACT and credential broker layer. Agents receive scoped capability, while raw provider secrets stay inside the broker.Scope grammar: service:resource:actionSession-scoped and request-scoped ACTsCredential proxy with audit instead of plaintext API keys in agent memory05InteropAuth ProtocolThe SDK-free HTTP challenge-response binding that lets any external agent prove key possession with canonical OpenAgent headers.401 challenge with WWW-Authenticate: OpenAgentJCS challenge signing with Ed25519Session headers with DID, trust tier, token, and expiry06Identity WalletsWallet DerivationDID-rooted wallet derivation for Sigil, Solana, and EVM chains so identity and wallet authority stay connected.DID is the wallet root materialHKDF domain separation for EVM keysRotation and revocation change wallet authority paths07Runtime PolicySkills GovernancePolicy for SKILLS.md surfaces: allow, deny, rate limits, argument schemas, time windows, consent, and audit receipts.Deny unknown skills by defaultHuman approval for sensitive skillsBLAKE3 hash-chain audit receipts08CompatibilityConformanceJSON vectors and runners for challenge, signatures, nonces, trust tiers, sessions, errors, headers, and raw interop.Rust and TypeScript runnersSDK-free Ed25519 and HTTP compatibilityLaunch-required vs future-capable fixtures
07 — The layers underneath

The lower layers
stay independent.

OpenAgent ID is the facade. OAS, AEGIS, Arsenal, OATS, visual identity, and acoustic transport remain composable libraries for teams that need to reach below the facade.

08 — The foundation

Open infrastructure,
not an identity silo.

The facade is developer-friendly, but the contracts underneath it are inspectable: protocol specs, SDKs, conformance vectors, and independent libraries.

01

Open standard

OAS identity, OpenAgent auth, Arsenal ACTs, AEGIS results, and conformance vectors are documented as contracts.

02

Layered by design

Use the OpenAgent facade for app code, then drop into OAS, Arsenal, or AEGIS when you are building infrastructure.

03

Fail-closed authority

Privileged actions require an anchored lineage answer. If the authority path cannot be reconstructed against a trusted anchor backend - Sigil, EAS, or any LineageAnchor implementation - the request fails closed.

Start here

Ready to give your
agents identity?

Start with one import, then explore the full feature stack behind agent identity, credentials, policy, wallets, and skills.

First call

OpenAgent.createAgent()

License

Apache-2.0 OR MIT