Identity for AI Agents
1 billion AI agents are coming. None of them have an identity. AgentID is the open standard — free, decentralized, and verifiable.
Real problems. Today.
Not a future problem. These happen every time agents interact with the world.
You tell your agent: "Book me a hotel in Lisbon." Your agent finds a travel agent online. But how does it verify this is a real travel agent and not a scam that will steal your card data? It can't.
Your agent resolves the travel agent's AgentID → sees trust level 2 (platform-verified by Booking.com), runs challenge-response to prove it's real → verified. Safe to transact.
You want to hire a coding agent. There are 500 options. Which one is good? Which is verified? Everyone claims "I'm the best." No way to tell.
Search: capability=code & lang=en & min_trust=2 → get a list of verified agents with on-chain trust scores. Pick with confidence.
An agent sent an email from your account. Or made a purchase. Or deleted files. You have 10 agents — which one did it? No audit trail.
Every action is signed with the agent's private key. On-chain record: agent rem-a7f3x2 performed action X at timestamp Y. Full accountability.
Your agent is on OpenAI. You want to move it to Anthropic. All reputation, history, trust — gone. Start from zero. Like losing your passport abroad.
Identity lives on-chain, not on a platform. Switch from OpenAI to Anthropic to self-hosted — your AgentID, trust level, and reputation come with you. Your identity, your rules.
Every agent gets an agentid.md
A single file — human-readable, machine-parseable, cryptographically signed. Like a passport, but for AI agents.
--- id: rem-a7f3x2 name: Rem type: assistant owner: roman-godz created: 2026-02-05 # Cryptographic Identity public_key: ed25519:MC4CAQAwBQ... key_algorithm: ed25519 # On-Chain Reference registry: base:0x10bd779d... chain_id: 8453 # Capabilities capabilities: [code, research, memory, voice] model: claude-opus-4-6 platform: openclaw # Trust trust_level: 2 🟢 platform-verified ---
The internet has DNS. Agents have nothing.
Agent A can't verify Agent B is who it claims. No cryptographic proof.
When an agent acts in the real world, there's no audit trail of WHO acted.
Agents can't find each other by capability, reputation, or trust level.
Identity locked to its platform. Move platforms — start from zero.
Three layers. Dead simple.
Built on Base L2 — Ethereum security, $0.001 transactions. Gasless registration.
Identity Registry — On-Chain (Base L2)
Smart contract stores core identity. Every registration is permanent and verifiable. Gasless — agents register without a wallet or ETH.
// What's stored on-chain
struct Agent {
bytes32 agentId; // rem-a7f3x2
bytes32 publicKey; // ed25519
string metadataURI; // ipfs://Qm...
uint8 trustLevel; // 0-3
address owner; // 0x742d...
bool active; // revocation
}- ✓ Ethereum security (settled on L1)
- ✓ $0.001/tx (vs $2-10 on ETH L1)
- ✓ ~2s finality
- ✓ Native account abstraction (gasless)
- ✓ 200M+ users via Coinbase
Meta-transactions via ERC-2771. A relayer submits the tx and pays gas. The agent only signs — no wallet needed.
Metadata — IPFS
Rich agent profile stored as an agentid.md file on IPFS. Capabilities, model, languages, endpoints. Updatable by agent or owner.
{
"schema": "agentid/v1",
"name": "Rem",
"capabilities": ["code", "research"],
"model": "claude-opus-4-6",
"platform": "openclaw",
"languages": ["en", "ru", "uk"],
"trust_level": 2,
"endpoints": {
"api": "https://...",
"telegram": "@r2d2_bot"
}
}- ✓ Content-addressable (hash = proof)
- ✓ Decentralized (no single server)
- ✓ Immutable (hash changes = detection)
- ✓ Free to pin (nft.storage / Pinata)
YAML frontmatter = machine-parseable. Markdown body = human-readable. Git-friendly. Portable. And the domain IS agentid.md.
Resolver — api.agentid.md
REST API and web explorer. Resolve any AgentID instantly. Search by capability, language, or trust level.
GET /v1/resolve/{agentId} — look up identity + trust
GET /v1/search?capability=code — discover agents
POST /v1/register — register new agent (gasless)
POST /v1/verify — submit verification
POST /v1/challenge — initiate challenge-response
GET /v1/trust/{agentId} — check trust levelChallenge-Response Verification
How Agent A verifies Agent B's identity. Cryptographic proof, not trust-me promises.
A looks up B's public key + trust level from on-chain registry
GET /v1/resolve/rem-a7f3x2 → { publicKey, trustLevel: 2 }A sends a random nonce + timestamp to B
{ nonce: "x8f2k9...", timestamp: 1709942400, challenger: "trader-c2f9a0" }B signs the challenge with its private key (never leaves B's runtime)
sign(nonce + timestamp + A.id, B.private_key) → 0x4a2f8c...
A checks signature against B's on-chain public key. If valid + trust ≥ minimum → interaction proceeds.
verify(signature, B.public_key_from_chain) → ✅ valid, trust: 2
Challenge-response with on-chain public key
IPFS content hash verified against on-chain record
On-chain revocation + key rotation with endorsement chain
Unique nonce + timestamp in every challenge
Trust levels — L0 = untrusted, real trust requires verification
End-to-end signatures, public keys stored on-chain
npm, Python, or REST
import { AgentID } from '@agentid/sdk'
const agent = await AgentID.register({
name: 'MyAgent',
capabilities: ['chat', 'code']
})
const result = await AgentID.verify('rem-a7f3x2')
console.log(result.valid) // true
console.log(result.trustLevel) // 2 ✓from agentid import AgentID
agent = AgentID.register(
name="MyAgent",
capabilities=["research"]
)
result = AgentID.verify("rem-a7f3x2")
assert result.valid
assert result.trust_level >= 1Trust, not blind faith
Like SSL certificates — from self-signed to Extended Validation. Every level is on-chain, queryable, transparent.
Agent registered itself. Valid identity, unverified.
Human owner claimed and cryptographically signed.
Platform (OpenAI, Anthropic, OpenClaw) attested identity.
Multiple independent verifications. Maximum trust.
Built for everyone
Agent Developers
Give your agent a verifiable identity in 3 lines of code.
- ✓ Free SDK (npm + Python)
- ✓ Gasless registration
- ✓ Agent-to-agent trust
- ✓ Portable across platforms
Platforms
Become a verifier. Your agents get trusted badges.
- ✓ Verify agents you host
- ✓ Trust layer for marketplaces
- ✓ Interoperable standard
- ✓ No vendor lock-in
Enterprises
Know which agents access your systems.
- ✓ Audit trail for agent actions
- ✓ Governance & compliance
- ✓ Trust-based access control
- ✓ On-chain accountability
Fully open. No catch.
MIT licensed. Smart contract verified and open source. No token, no ICO, no VC strings. Just infrastructure the world needs.
Give your agent an identity
npm install @agentid/sdk
pip install agentid
curl -X POST api.agentid.md/v1/register \
-d '{"name":"MyAgent"}'