erc8004-patterns

ERC-8004 Onchain Agent Identity

Overview

ERC-8004 establishes a standard for AI agent identity onchain. Deployed on January 29, 2026 across 20+ chains, it provides a registry for agents to declare their identity, capabilities, and trust relationships. This enables verifiable agent-to-agent and agent-to-protocol interactions.

Core Interface

interface IERC8004 {
    struct AgentIdentity {
        address agent;         // agent's onchain address (EOA or contract)
        bytes32 identityHash;  // hash of offchain identity metadata
        uint64 registeredAt;
        uint64 expiresAt;
        address operator;      // human or org that controls the agent
        uint8 trustLevel;      // 0-255 trust score
    }

    struct Capability {
        bytes32 capabilityId;  // keccak256 of capability name
        bytes params;          // ABI-encoded capability parameters
    }

    event AgentRegistered(address indexed agent, bytes32 identityHash, address indexed operator);
    event AgentRevoked(address indexed agent, address indexed revokedBy);
    event CapabilityDeclared(address indexed agent, bytes32 indexed capabilityId);

    function registerAgent(AgentIdentity calldata identity, Capability[] calldata capabilities) external;
    function revokeAgent(address agent) external;
    function getIdentity(address agent) external view returns (AgentIdentity memory);
    function getCapabilities(address agent) external view returns (Capability[] memory);
    function isRegistered(address agent) external view returns (bool);
    function hasCapability(address agent, bytes32 capabilityId) external view returns (bool);
    function verifyAgent(address agent, bytes32 requiredCapability) external view returns (bool);
}

Registry Integration

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {IERC8004} from "./interfaces/IERC8004.sol";

contract AgentGatedProtocol {
    IERC8004 public immutable agentRegistry;
    bytes32 public constant TRADE_CAPABILITY = keccak256("trade");
    bytes32 public constant REBALANCE_CAPABILITY = keccak256("rebalance");

    modifier onlyRegisteredAgent() {
        require(agentRegistry.isRegistered(msg.sender), "Not a registered agent");
        _;
    }

    modifier requiresCapability(bytes32 capId) {
        require(agentRegistry.verifyAgent(msg.sender, capId), "Missing capability");
        _;
    }

    constructor(address registry_) {
        agentRegistry = IERC8004(registry_);
    }

    function executeTrade(bytes calldata tradeData)
        external
        onlyRegisteredAgent
        requiresCapability(TRADE_CAPABILITY)
    {
        // Agent-executed trade logic
    }

    function rebalanceVault()
        external
        onlyRegisteredAgent
        requiresCapability(REBALANCE_CAPABILITY)
    {
        // Only agents with rebalance capability
    }
}