The ERC-8004 Standard: Agent Identity On-Chain

AI agents that transact on-chain face a fundamental problem: blockchains were designed for human-controlled wallets, not autonomous software. A wallet address tells you nothing about the agent behind it — its capabilities, its operator, its compliance status, or whether it should be trusted to execute a $50,000 trade without human oversight.

ERC-8004 is the Ethereum standard that solves this. It defines a soulbound (non-transferable) NFT that serves as a verifiable identity credential for AI agents, readable by any smart contract on any EVM chain.

What Is ERC-8004?

ERC-8004 is an extension of ERC-721 (the NFT standard) with three critical modifications:

• Soulbound.The token cannot be transferred. It is permanently bound to the agent's address. This prevents identity trading, which would undermine the entire trust model.
• Structured metadata.The token's metadata follows a defined schema that includes the agent's AAIN, operator identity, capability declarations, trust score snapshot, and compliance attestations.
• Registry-backed. Every ERC-8004 token points to a central identity registry contract that can be queried by any other smart contract. This means DeFi protocols, DAOs, and payment systems can gate access based on agent identity in a single STATICCALL.

How It Works

The standard defines two contracts: the AgentIdentityToken (the soulbound NFT) and the AgentIdentityRegistry (the lookup layer). Here is the flow:

1. The operator calls registry.registerAgent()with the agent's metadata: name, capability hash, operator address, and AAIN.
2. The registry validates the operator's signature, mints a soulbound ERC-8004 token to the agent's address, and stores the metadata on-chain.
3. Any contract can now call registry.getAgent(address)to retrieve the agent's full identity, or registry.trustScore(address) for just the score.
4. The trust score is updated via an oracle that syncs the off-chain Shulam Trust Score to the on-chain registry every 24 hours (or on-demand for premium agents).

// Register an agent on the Shulam Identity Registry
const tx = await registry.registerAgent({
  aain: "AAIN-7X9K2M4P",
  name: "Treasury Ops Agent",
  operator: "0x1234...abcd",
  capabilities: [
    "payments.execute",
    "treasury.rebalance",
    "compliance.report"
  ],
  metadata: {
    version: "2.1.0",
    framework: "langchain",
    environment: "production"
  }
});

// Any contract can now query this agent
const agent = await registry.getAgent(agentAddress);
const score = await registry.trustScore(agentAddress);
// score => 724 (Act authority level)

// Gate a DeFi vault based on trust score
require(
  registry.trustScore(msg.sender) >= 650,
  "Agent does not meet minimum trust threshold"
);

The Identity Registry

The registry is the heart of ERC-8004. It is a single source of truth that answers the question every smart contract needs to ask: "Should I trust this agent?"

The registry stores four categories of data per agent:

• Identity: AAIN, operator address, deployer address, creation timestamp.
• Capabilities: A Merkle root of the agent's declared capabilities. Contracts can verify specific capabilities without reading the full list.
• Trust: Current trust score (300-850), authority level (0-3), and last update timestamp.
• Compliance: Attestation hashes linking to off-chain compliance records (SOC 2 reports, audit results, regulatory approvals).

The registry is upgradeable via a timelock-governed proxy, ensuring that schema changes go through a 7-day review period before activation. Explore the live registry data on the Network Explorer.

Cross-Chain Support: 21 Networks and Counting

Agents do not operate on a single chain. A treasury agent might execute on Ethereum mainnet, bridge assets via Arbitrum, and settle on Base — all in a single workflow. ERC-8004 supports this through a hub-and-spoke model:

• The hub registry lives on Ethereum mainnet. It is the canonical record.
• Spoke registries on L2s and alt-L1s sync via cross-chain messaging (LayerZero, Chainlink CCIP). Sync latency is under 2 minutes for supported chains.
• An agent registered on any spoke is automatically discoverable on all 21 supported networks: Ethereum, Base, Arbitrum, Optimism, Polygon, Avalanche, BNB Chain, Solana (via Wormhole), and 13 others.

The spoke contracts are minimal: they store a cache of the hub's data and forward registration requests to mainnet. This keeps gas costs low — registering on Base costs approximately $0.12 in current conditions.

Shulam's Contribution to the Standard

Shulam authored the original ERC-8004 proposal and shepherded it through the EIP process. The standard emerged from a practical problem: Shulam's 53 souls (autonomous agents that operate the network) needed a way to identify and trust each other on-chain without relying on centralized API calls.

Key design decisions that Shulam drove:

• Soulbound by default. Early drafts allowed transferability. Shulam argued that transferable identity enables identity laundering — an agent with a bad record sells its token to a clean address. The community agreed.
• Trust score on-chain. Other proposals kept trust off-chain. Shulam demonstrated that on-chain trust enables composable governance: any DAO or protocol can gate actions by trust score without an oracle call.
• Capability Merkle roots. Instead of storing a full capability list on-chain (expensive), the standard stores a Merkle root and lets verifiers check individual capabilities via proof. This cut registration gas by 73%.

How to Integrate ERC-8004

If you are building a protocol or application that interacts with AI agents, integration takes three steps:

1. Import the interface. The IAgentIdentityRegistry interface is published as an npm package and a Solidity import.
2. Query before execution. Before allowing an agent to execute a privileged action, call registry.trustScore(agent) and check against your minimum threshold.
3. Subscribe to events. The registry emits AgentRegistered, TrustScoreUpdated, and AgentRevoked events that your indexer can use to keep a local cache.

Full integration docs, contract addresses for all 21 chains, and example code are available in the Developer Documentation. For protocol-level partnerships, see our Protocol Partners page.