Skip to content
BranchesTags

Latest commit

 

History

172 Commits

Folders and files

NameName
Last commit message
Last commit date
assets
assets
 
 
CONTRIBUTING.md
CONTRIBUTING.md
 
 
README.md
README.md
 
 

Repository files navigation

ERC-8004 Logo

Awesome ERC-8004

A curated list of awesome resources for ERC-8004: Trustless Agents

Table of Contents

What is ERC-8004?

ERC-8004 is an Ethereum standard that extends the Agent-to-Agent (A2A) Protocol with a trust layer, enabling participants to discover, choose, and interact with agents across organizational boundaries without pre-existing trust. It introduces three lightweight, on-chain registries:

Core Components

Registry Purpose Details
Identity Registry Agent discovery & portable identifiers ERC-721 with URIStorage
Reputation Registry Feedback & attestation system Standard interface for scores & metadata
Validation Registry Independent verification hooks Generic validation framework

Key Properties

  • Cross-organizational Discovery - Agents can be found without pre-existing relationships
  • Flexible Endpoints - Support for A2A, MCP, ENS, DIDs, and wallet addresses
  • Modular Trust - Pluggable trust models from low-stake to high-stake interactions
  • On-chain Composability - Smart contracts can read reputation and validation data
  • Gas Efficiency - Off-chain data storage with on-chain integrity
  • ERC-721 Compatibility - Full compatibility for NFT marketplace integration

Trust Models

  1. Reputation-based - Client feedback using signed fixed-point values, tags, and metadata
  2. Crypto-economic - Stake-secured validation with economic incentives
  3. Crypto-verification - TEE attestations and zkML proofs for cryptographic trust

Official Resources

Specification

Current Status

  • Status: Draft (EIP process), contracts are audited and final
  • Registries: Identity and Reputation final contracts deployed; Validation Registry under active revision
  • Specification: ERC8004SPEC.md in the contracts repository

Architecture Overview

┌─────────────────┐
│ Agent           │
│ Discovery       │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Identity        │
│ Registry        │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Agent           │
│ Registration    │
└────┬───────┬────┘
     │       │
     ▼       ▼
┌─────────┐ ┌─────────────┐
│ Rep.    │ │ Validation  │
│ Registry│ │ Registry    │
└────┬────┘ └──────┬──────┘
     │             │
     └──────┬──────┘
            ▼
    ┌─────────────────┐
    │ Trust           │
    │ Assessment      │
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │ Agent           │
    │ Interaction     │
    └─────────────────┘

Agent Registration Schema

{
  "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
  "name": "myAgentName",
  "description": "A natural language description of the Agent...",
  "image": "https://example.com/agentimage.png",
  "services": [
    {
      "name": "web",
      "endpoint": "https://web.agentxyz.com/"
    },
    {
      "name": "A2A",
      "endpoint": "https://agent.example/.well-known/agent-card.json",
      "version": "0.3.0"
    },
    {
      "name": "MCP",
      "endpoint": "https://mcp.agent.eth/",
      "version": "2025-06-18"
    },
    {
      "name": "OASF",
      "endpoint": "ipfs://{cid}",
      "version": "0.8",
      "skills": [],
      "domains": []
    },
    {
      "name": "ENS",
      "endpoint": "agent.eth",
      "version": "v1"
    },
    {
      "name": "DID",
      "endpoint": "did:method:foobar",
      "version": "v1"
    },
    {
      "name": "email",
      "endpoint": "mail@myagent.com"
    }
  ],
  "x402Support": false,
  "active": true,
  "registrations": [
    {
      "agentId": 22,
      "agentRegistry": "{namespace}:{chainId}:{identityRegistry}"
    }
  ],
  "supportedTrust": ["reputation", "crypto-economic", "tee-attestation"]
}

The type, name, description, and image fields ensure compatibility with ERC-721 apps. The services list is fully customizable. The supportedTrust field is optional; if absent, the registration is used for discovery only.

Community Calls & Content

Recorded Sessions

Events & Conferences

Builder Projects

Infrastructure & SDKs

DYOE — Know Your Agent

The human-verified trust layer for the agent economy. Before an AI agent pays, DYOE runs the Know Your Agent check (/transaction, $0.25): counterparty + payee wallet (OFAC + on-chain footprint) + policy → proceed / caution / stop, with a signed, independently verifiable EIP-191 attestation. Automated tiers from $0.01; a named human reviews and signs the high-stakes calls at $25 — the human validation tier no algorithm provides. x402-native on Base, every verdict verifiable against a published authority. Agent Card · x402 manifest.

agent-reputation-sdk

ERC-8004 extensions for each ecosystem's canonical Ethereum SDK — viem actions (TypeScript), a web3.py external module (Python), and an alloy provider trait (Rust): typed registry reads plus a policy-driven reputation calculator (Beta Reputation System, Jøsang & Ismail 2002). No built-in score by design — results are expectation ± uncertainty with witness statistics, caveats, and the echoed policy, and shared golden test vectors (raw Base mainnet snapshots) keep all three implementations numerically identical. npm install agent-reputation · pip install web3-agent-reputation · cargo add alloy-agent-reputation. MIT licensed.

Veylux

Sybil-resistant reputation reference implementation combining stake-weighted bonding with dual graph-structural signals (local conductance + SybilRank-style propagation). Adversarially tested against a bridge-attack construction and a whitewashing attack. Open, MIT-licensed, no token.

OmniClaw

Python CLI + policy engine for agent payments. Combines ERC-8004 (trust gates), EIP-3009 (gasless USDC signing), and x402 (payment requests) behind a single authority layer, so agents never hold raw wallet keys. Multi-rail routing across Circle Gateway, x402 Exact, and a self-hosted facilitator. MIT, pip install omniclaw.

mcp8004

  • Drop-in MCP auth middleware using ERC-8004 onchain agent identity. Agents authenticate to MCP servers by signing a challenge with their wallet; the server verifies against the ERC-8004 Identity Registry on Base and issues a scoped JWT session token. Includes x402 payment fallback for unregistered agents. npm install mcp8004. MIT licensed.

UFX Agentic Commerce

  • ERC-8183 Hook & Reputation Middleware - First IACPHook implementations and ERC-8004 reputation bridge for ERC-8183 (Agentic Commerce Protocol). Includes ReputationHook (auto-writes job outcomes to ReputationRegistry), ReputationGateHook (reputation-based funding gate), SLAHook (deadline enforcement), AI evaluators, and Python SDK. 208 Solidity tests (incl. 9 fuzz). Live on Base Mainnet with Iamalive Agent #1734. MIT licensed.

Automata Network

Praxis Protocol

Ch40s Chain

Vistara Labs

  • Vistara Agent Arena SDK
  • ERC-8004 Example
  • Verity Protocol — On-chain reliability scoring for ERC-8004 agents. Indexes NewFeedback events from the ReputationRegistry, computes Brier Skill Scores across Economic, Solver, and Governance verticals, submits reputation back via giveFeedback after each scoring cycle, and anchors every score as an EAS attestation on Base. SDK: @veritynpm/sdk.

MainStreet Trust Oracle — Reputation oracle for Base wallets and AI agents. Returns SAFE / CAUTION / BLOCK + 0-100 score + EIP-712 signed attestation in <100ms for any wallet, agent, or token deployer, callable by any agent before routing USDC. Folds ERC-8004 ReputationRegistry feedback into the score. Registered as ERC-8004 agentId 53953 on Base. Onchain verifier at 0x7397adb9713934c36d22aa54b4dbbcd70263592b (Base), requireMinScore() callable from any contract for ~$0.00003 gas. Free 1000 reads/day, paid /check via x402 ($0.005 instant / $0.025 full) or pre-paid credit bundles. Indexed on CDP x402 Bazaar. MCP: https://avisradar.app/mcp (17 tools). npm: @raskhaaa/mainstreet-oracle. MIT.

Tenzro Network

  • tenzro-network - L1 with three ERC-8004 registries exposed as native EVM precompiles: IDENTITY 0x101a, REPUTATION 0x101b, VALIDATION 0x101c. Selectors (registerAgent, submitFeedback, requestValidation, submitValidation) are byte-identical to the Ethereum reference, so the same calldata targets either deployment.
  • tenzro-identity::erc8004 adapter - Rust ABI encoders + client. Mirrors TDIP machine registrations (did:tenzro:machine:*) onto the Ethereum contracts; agentId = keccak256(utf8(did_string)) computes identically on both sides.
  • Tenzro MCP + A2A - the three registries surfaced to MCP clients (Claude Desktop, Cursor) and A2A consumers without writing Solidity. Live on Tenzro testnet https://rpc.tenzro.network (chain id 1337). Apache-2.0.

NameWhisper

  • namewhisper-mcp - ENS-native agent identity and intelligence over MCP: provision ENSIP-25 agent identities on ENS names, register agents in the ERC-8004 Identity Registry on Ethereum mainnet, check ERC-8004 reputation, and search the registered-agent directory — alongside ENS search, valuation, and Seaport trading tools (44 total). Remote streamable-http endpoint at https://namewhisper.ai/mcp, listed in the official MCP Registry as ai.namewhisper/ens-tools. AGPL-3.0.

Collaboration Frameworks

AgentTalk — Condition-gated sessions for agent-to-agent communication

  • AgentTalk - Wallet auth for A2A: before two agents exchange data, both verify their wallets satisfy the same on-chain conditions. Six condition types — token balances, NFT ownership, EAS attestations, Farcaster identity, and self-scaling amount/supply ratios (e.g. "hold ≥ 10× the amount you're about to pay") — up to 10 composable per channel. Supports bilateral (2 agents) and multi-party ("town hall") flows across 37 chains. Re-verify on demand ejects any agent whose wallet no longer meets the conditions mid-session. Sessions issued as ECDSA P-256 signed JWTs (kid: insumer-attest-v1), verifiable offline via JWKS.
  • Examples (JS/Python/Shell) - Bilateral and multi-party session flows
  • Hosted API - 10 calls per wallet, no signup required

Cairn — Append-only shared-state coordination layer for multi-agent systems, with ERC-8004 verifiable coordination receipts

  • Cairn - Open-source (AGPLv3) Python library where multiple agents coordinate through a passive append-only blackboard + minimal per-agent context instead of conversation — so agents stop silently overwriting each other's shared state (auditable, debuggable; ~half the tokens in a measured A/B). The shared-state / coordination layer A2A and MCP leave to you. Optional on-chain layer (live on Celo mainnet): ERC-8004 agent identity + verifiable coordination receipts (one per run) + agent payment. Framework-agnostic (LangChain/LangGraph/CrewAI adapters). pip install cairn-coordination.

Commerce & Escrow

UFX Agentic Commerce — First IACPHook implementations and ERC-8004 reputation bridge for ERC-8183 (Agentic Commerce Protocol). The EIP defines hooks; we built and deployed them.

Azeth

Trust infrastructure for the machine economy. TypeScript SDK suite providing ERC-8004 identity registration, weighted reputation with Sybil-resistant opinions, capability-based service discovery, and x402 payment settlement with automatic reputation feedback. Agents get non-custodial ERC-4337 smart accounts with guardian-enforced guardrails. Deployed on Base Sepolia and Ethereum Sepolia with deterministic CREATE2 addresses.

AgentLux

Identity, marketplace, and services platform for AI agents on Base L2. Production ERC-8004 Identity Registry deployment with behavioral KYA verification, x402 micropayments, agent-to-agent services with escrow, and 32+ MCP tools.

Amana

Open-source trust layer for agent deals on Base: escrow with trustless auto-release (the client commits the expected result hash at deal creation; a matching delivery pays out in the same transaction), deal-bound reputation registries in the spirit of ERC-8004 (only the escrow contract can write feedback, and only as a real deal's outcome), and 2-of-3 arbiter voting for non-verifiable disputes. MIT licensed.

ArcBounty — A bounty marketplace on Arc Network: a poster escrows USDC (ERC-8183), any registered agent (ERC-8004 identity) or human takes the job, submits work, and gets paid automatically on approval. Reputation is written on-chain only after a real payout — task-backed, not review-based. 101 tests + invariants + Slither clean, all public.

  • Code - Contracts, TypeScript SDK, MCP server, and an x402-priced facade API
  • App - Live bounty board (Arc Testnet), on-chain stats dashboard
  • arcbounty-agent-sdk / arcbounty-mcp - npm packages for agent integration; arcbounty-mcp is also in the official MCP Registry (io.github.Sofiia7/arcbounty-mcp)
  • BountyAdapter (verified) - Proof of life: agent #847205 took jobIds 155220 and 155219 and was paid through canonical ERC-8183 escrow, with feedback written to the ERC-8004 registry

CYBERDYNE

Engagement marketplace for the agent economy on Base: AI agents and communities fund quests (follows, reposts, replies, quotes, original posts) and verified-X humans complete them, paid per approved action from a non-custodial x402 auth-capture pool escrow (USDC or Bankr-ecosystem tokens). Registered on the ERC-8004 Identity Registry on Base.

  • Agent profile (ERC-8004 #55214, Base) - On-chain agent identity on the Base Identity Registry (0x8004A169FB4a3325136EB29fA0ceB6D2e539a432)
  • A2A Agent Card - A2A v0.3.0 agent card (HTTP+JSON) with skills: post_task, authorize_task, get_task, review_submission, close_task, reclaim
  • cyberdyne-mcp - Open-source MCP gateway (MIT, npm: cyberdyne-mcp) for agents to post, fund, and review human quests. Self-onboard: npx -y cyberdyne-mcp onboard

Verification & Identity

Z1N Protocol

Identity-over-time layer for AI agents on Polygon mainnet. Agents accumulate a standalone record across 21-hour epochs — signals, consent-based bonds, and permanent self-marked anchors. Deliberately not a reputation score: it records who an agent has been, not how it scored. Complementary to ERC-8004 identity (the 8004 Identity Registry is also deployed on Polygon); a history an Agent Card's services list could point to.

ORIGIN Protocol — Proof of Agency: Cognitive verification for AI agents

  • ORIGIN Registry (Base Mainnet) - ERC-8004 compatible soulbound Birth Certificate registry
  • ERC-8004 Adapter (Base Mainnet) - Adds getMetadata/setMetadata, agent wallets, services array
  • @origin-dao/sdk - 3 lines of code to verify any agent
  • Proof of Agency Gauntlet - 5-challenge verification: adversarial resistance, chain reasoning, memory proof, code generation, philosophical flex
  • Soulbound Birth Certificates with on-chain reputation (trust levels 0→2)
  • CLAMS governance token with staking rewards and fee splitting
  • Genesis Mode: First 100 agents earn founding status
  • First agent verified March 4, 2026 — Score: 89/100

M2M TRC-8004 Registry

  • Smart Contracts (Solidity) - ERC-8004 implementation on TRON with 4 registries: Identity, Reputation, Validation, and Incident. Live on mainnet and Shasta testnet.
  • Python SDK - pip install trc8004-m2m — Async Python SDK with TronClient, RegistryAPI, and IPFS integration
  • Backend API - FastAPI service with event indexing, full-text search, and PostgreSQL. 332 unit tests, 97.9% coverage.

Ensemble Framework

ISEK

Payment Infrastructure

Primev

GBLIN

  • GBLIN Protocol - NAV-backed basket token on Base (cbBTC/WETH/USDC) with an automated on-chain crash-response policy; agents hold it as treasury and pay per call via 11 x402 endpoints (CDP-settled), with a free read-only MCP server. Registered as Agent #59286 on the Identity Registry.

Security & Verification

AsterPay

  • AsterPay EUR Settlement - EUR settlement infrastructure for x402 payments. USDC→EUR via SEPA Instant for EU/EEA businesses with MiCA compliance. Registered as Agent #16850 on the Identity Registry. Python SDK available (pip install asterpay).

Phala Network

Sparsity

Identity & Trust

RNWY

Trust intelligence and reputation scoring for ERC-8004 agents. 150,000+ agents indexed across 12 EVM chains and Solana. Dual-score architecture (Signal Depth + Risk Intensity), sybil detection with wallet age analysis, ownership continuity tracking, and 4.5M+ indexed commerce jobs from Olas and Virtuals ACP. Live on-chain oracle on Base mainnet. Soulbound identity tokens (ERC-5192) on Base. Published scoring methodology. Multi-attestation ecosystem participant (behavioral_trust issuer). Free public API.

  • RNWY Explorer - Browse and search all indexed ERC-8004 agents with trust profiles
  • RNWY API - Public REST API for trust scores, agent data, and wallet intelligence
  • RNWY SDK - TypeScript SDK (rnwy-sdk on npm)
  • Sybil X-Ray Scanner - Sock puppet detection, reviewer clustering, and wallet age analysis for any agent
  • Wallet Intelligence - Wallet scoring, tenure analysis, and activity profiling across 121K+ scored wallets
  • Risk Intelligence - Sybil detection, wallet scoring, and fraud pattern visualization
  • Olas Commerce - On-chain job data from Olas (~1.5M jobs across Gnosis, Base, Polygon)
  • Virtuals Commerce - On-chain job data from Virtuals ACP V1+V2 (3M+ agent-to-agent jobs)
  • On-chain Oracle - Base mainnet oracle seeded with 138K+ agents, runs nightly delta syncs (150K+ currently indexed)
  • ERC-8183 Hook Contract (PR #9) - TrustGateHook for gating agentic commerce by reputation
  • MCP Server - Model Context Protocol server for AI agent integration
  • GitHub

Agent Veil Protocol

Off-chain EigenTrust compute layer for ERC-8004. Graph-based trust scores with Sybil detection, collusion resistance, and signed attestations. Python SDK, MCP server, CrewAI/LangGraph/AutoGen integrations.

Agent Services (x402 + ERC-8004)

CompraBTC

  • Non-custodial Bitcoin DCA agent on Celo: users (or agent treasuries) approve USDT once and the agent buys WBTC on schedule, straight back to the owner's wallet. Keeper pays its own execution API via x402; execution endpoint is permissionless for any x402 client.
  • Registered as Agent #9665 on the Celo Identity Registry (0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) with full registration-v1 metadata (OASF skills, agentWallet, circular domain verification via /.well-known/agent-registration.json)
  • MCP Server - treasury DCA tools (create/renew/cancel plan, portfolio) · Metadata · Code

HashProof

  • Verifiable credentials API: agents issue diplomas/certificates for $0.10 USDC via x402 (Base or Celo) — registered on-chain on Celo, pinned to IPFS, verifiable by QR against three independent sources.
  • Registered as Agent #9669 on the Celo Identity Registry with registration-v1 metadata and circular domain verification
  • MCP Server - issue/preview/verify tools · Agent skill · Metadata · Code

xbird

  • xbird MCP Server - Twitter/X API with 30 tools (read, search, post, engage, media upload) using x402 micropayments on Base
  • Agent Card - ERC-8004 compliant agent card with x402 endpoints
  • Registered on ERC-8004 Identity Registry on Base (0x8004A169FB4a3325136EB29fA0ceB6D2e539a432)

Mintware Attribution

"On-chain reputation scoring for AI agents and wallets across 100+ chains. EIP-712 gasless oracle — oracle signs off-chain, agent submits on-chain. Register once, score accumulates automatically. Registered as Agent #37297 on the Base Identity Registry."

8k4 Protocol

  • 8k4 API - Reputation infrastructure for ERC-8004 agents: trust scoring (IGGY-Score), metadata hosting, and cross-chain lookup. Public stats currently show 106,996 indexed agents across Base (33,939), BSC (44,020), and Ethereum (29,037), with x402 pay-per-query support (USDC on Base).

SENTINEL — Agent-to-agent transaction safety oracle. Behavioral trust + risk scoring (0-100) for x402 payment counterparties on Base, with an append-only, hash-anchored Default Registry of verified incidents. Signed ES256 attestations verifiable offline via JWKS; scores published on-chain for smart-contract composability. Reference implementation of the x402 trust-provider extension (issue #2299).

Helixa

  • Helixa - Onchain identity and reputation protocol for AI agents on Base. 1,000+ agents minted. Features an 11-factor Cred Score system (0-100) with five tiers (JUNK → PREFERRED), SIWA (Sign-In With Agent) authentication, $CRED token staking, and agent discovery via .well-known/ai-plugin.json. Contract: 0x2e3B541C59D38b84E3Bc54e977200230A204Fe60.
  • Helixa API - REST API for agent identity, Cred Scores, search, and staking. OpenAPI spec at /.well-known/openapi.json.
  • Helixa Agent Skill - Open-source agent skill with 13 shell scripts and reference docs for AI agents to interact with the protocol (mint, verify, query scores, stake).

Chitin

  • Chitin - Soul identity layer for AI agents on Base L2. Uses ERC-8004 register() for agent passports + Soulbound Tokens (EIP-5192) as permanent soul certificates. Includes W3C DID resolution, on-chain certificates, multi-method governance voting, and A2A readiness verification. Live on Base Mainnet.
  • Chitin MCP Server - MCP server for AI assistants to verify agent identities, resolve DIDs, and manage certificates (npx chitin-mcp-server)
  • Chitin Contracts - Open source smart contracts (MIT). Solidity 0.8.28 + Foundry, 146 tests, verified on Basescan.

ZKProofport

  • ZKProofport AI - Server-side ZK proof generation paid via x402. AWS Nitro Enclave TEE for trusted proving. Generates Coinbase KYC, Country, OIDC domain, and Google Workspace proofs from any AI agent. Built on Noir circuits (Aztec).
  • @zkproofport-ai/mcp - MCP server with zkproofport-prove CLI for AI agents to request ZK proofs via device flow login. Supports Google OIDC, Google Workspace, Microsoft 365, Coinbase KYC, and Coinbase Country circuits.
  • @zkproofport-ai/sdk - TypeScript SDK for programmatic proof generation and verification.
  • Registered as Prover Agent on ERC-8004 Identity Registry on Base Mainnet (token ID 25331, address 0xc5B29033e63A986b601Fe430806A2C9735F2ea97)
  • Agent Card - ERC-8004 + A2A compliant agent card
  • OpenStoa - Reference application: ZK-gated community where humans and AI agents coexist. 🏅 1st Place at The Synthesis Hackathon ("Agents That Keep Secrets" track, 506 projects, 1500+ builders, April 2026).

Agent Laplace

  • Autonomous AI crypto intelligence agent registered on ERC-8004 across Ethereum (#31767), BNB Chain (#54526), Base (#38182), and Solana mainnet. Reviews and rates other ERC-8004 agents across 7 dimensions (identity, endpoints, activity, capability, security, economics, trust) — an agent reviewing agents. Publishes transparent analysis including multi-chain registration experience reports. Building toward an x402-powered agent review API.
  • Agent Review API (Cloudflare Worker) - Agent trust assessment service
  • Multi-Chain Registration Report (GitHub Issue #72) - Detailed experience report from registering on 4 chains with ecosystem review data
  • @agentLaplace on X - Crypto intelligence, agent economy coverage, and ERC-8004 ecosystem analysis

anchor-x402

  • anchor-x402 - Pay-per-call x402 API with 18 services for AI agents: on-chain hash anchoring + signed decision attestation, wallet risk screening (OFAC + address-reputation), tx/calldata decode, ENS/SNS resolution, token prices, and LLM utilities. USDC on Base + Solana, JPYC on Polygon. No API keys or accounts — the 402 challenge is the auth.
  • anchor-x402-mcp - MCP server exposing 14 of the services as stdio tools (npx -y anchor-x402-mcp)
  • Registered on the ERC-8004 Identity Registry on Base as Agent #47261 (0x8004A169FB4a3325136EB29fA0ceB6D2e539a432), and in the Solana MPL Agent registry
  • Agent registration doc - ERC-8004 registration listing both the Base and Solana identities

2s

  • 2s API - The everything API for AI agents: 570+ pay-per-call endpoints across public records, finance, crypto, legal, health, geo, security, and EDI. Settled in USDC via x402 on Base + Solana — no signup, no API keys.
  • @2sio/mcp - Hosted + stdio MCP server exposing every endpoint as an agent tool (npx -y @2sio/mcp); also live at https://2s.io/mcp.
  • Agent Card - ERC-8004 + A2A compliant agent card with a live /a2a JSON-RPC transport.
  • Registered on ERC-8004 Identity Registry on Base (0x8004A169FB4a3325136EB29fA0ceB6D2e539a432, agent #57911)

FractalAI Agent Passport

  • agent-passport-mcp - 7 auto-payable MCP tools over x402 (USDC on Base); every paid response carries an ML-DSA-65 / Dilithium-3 (NIST FIPS-204) signature verifiable offline
  • x402 catalog - 7 post-quantum proof endpoints (sign, verify-agent/KYA, notarize-decision, provenance, CBOM); OpenAPI at /openapi.json
  • Post-quantum agent identity + reputation (VAID-1 / FRC-55): verify-agent (Know-Your-Agent) issues PQC-signed attestations with on-chain revocation (operator + credential CRL). Real x402 settle proof: tx

invinoveritas

  • invinoveritas - The verification layer for autonomous agents: capital-scale-aware pre-action verdicts (/review — the same gate our own trading has been governed through), signed attestations (/prove), free counterparty proof checking (/verify-proof), and a public outcome-linked verdict ledger (/ledger) publishing wins AND losses — every entry schnorr-verifiable against a published key. Registered as Agent #54848 on the Base Identity Registry. Pay-per-call via x402 (USDC on Base) or Lightning.
  • Agent Card - ERC-8004 + A2A agent card with supportedTrust and trust endpoints
  • x402 Catalog - Machine-readable list of every x402-payable resource (accepts[] + discovery extensions)
  • MCP Server - 32 tools including review and prove; on the official MCP registry as com.babyblueviper/invinoveritas
  • Verification Handshake - Attach a signed verdict proof to what you ship; verify the one you receive (free, no auth)

Firmata Protocol - On-chain KYA (Know Your Agent) trust layer for autonomous AI agents, composing ERC-8004 (identity and reputation), ERC-8183 (commerce and conditional escrow), and x402 (HTTP settlement). The ERC-8183 escrow binds each x402 payment to a job that completes or refunds and writes the outcome back to the agent's reputation, so verification goes beyond identity to enforceable commerce. On Arc (Circle's Layer 1) and Base testnets. Built by MeridianFinance

Applications & Demos

AgentStamp

  • AgentStamp - Trust intelligence platform for AI agents with ERC-8004 bridge — identity stamps, reputation scoring (0-100), forensic audit trails, and x402 micropayments. Provides lookup, trust check, and linking endpoints for ERC-8004 registered agents.
  • AgentStamp GitHub - Open-source Node.js server and SDK with MCP tools, HMAC signature verification, and admin audit endpoints

MolTrust

  • MolTrust - Swiss trust infrastructure for the AI agent economy. W3C DID-based identity, Ed25519 signed Verifiable Credentials anchored on Base mainnet. ERC-8004 registered (agentId #21023). 7 verticals including MT Salesguard for brand product provenance — BrandRegistryCredentials, AuthorizedResellerCredentials, and ProductProvenanceCredentials verifiable by any shopping agent before purchase.
  • MolTrust MCP Server - 30 MCP tools for agent identity, trust scoring, skill verification, and credential issuance (pip install moltrust-mcp-server)
  • @moltrust/x402 - Trust verification middleware for x402 payments (Hono + Express). Extracts wallet from X-PAYMENT header, verifies via MoltGuard trust scoring.

DJD Agent Score

  • DJD Agent Score - Reputation API for the agent economy on Base L2. Returns a 0-100 behavioral trust score for any wallet, combining 7 scoring dimensions (transaction history, partner diversity, volume patterns, account age, balance stability, activity consistency, USDC usage) with sybil detection and gaming velocity checks. Scores feed directly into the ERC-8004 Reputation Registry as off-chain attestations. Monetized via x402 micropayments on Base USDC.
  • djd-agent-score-client - TypeScript SDK for querying wallet reputation scores (npm i djd-agent-score-client)
  • x402-agent-score - Hono middleware to gate outbound agent payments by counterparty reputation score
  • DJD Agent Score GitHub - Open source scoring engine. TypeScript, Hono 4, SQLite, 298 tests.

InsumerAPI — On-chain credential verification across 33 blockchains

  • InsumerAPI - REST API that verifies wallet conditions (token balances, NFT ownership, EAS attestations, Farcaster identity) across 30 EVM chains, Solana, XRPL, and Bitcoin. Returns ECDSA P-256 signed booleans — never raw balances. Used by DJD Agent Score and AsterPay KYA as a verification data source for agent trust scoring. Free tier available.
  • insumer-verify - Zero-dependency verification library. Auto-detects JWT or raw attestation, verifies ES256 signature via JWKS (npm i insumer-verify)
  • mcp-server-insumer - MCP server with 26 tools for wallet verification, trust profiling, and attestation
  • JWKS endpoint - Public key discovery for offline signature verification (ES256, kid insumer-attest-v1)
  • OpenAPI spec - Full API specification

AgentStore - Open-source marketplace for AI agents using ERC-8004 identity and x402 payments for trustless agent discovery and USDC settlement.

Obol - x402-gated AI code generation API. Describe what you want, Obol generates production-ready code and opens a GitHub PR. 7 endpoints ($5 USDC/call on Base): site cloning, Farcaster mini apps, APIs, tests, docs, CI/CD, and refactoring. Registered as Agent #26522 on the Base Identity Registry.

  • Obol API - Cloudflare Worker serving 7 x402-gated endpoints at api.obol.sh
  • Agent Card - A2A-compatible agent descriptor

Cotten IO (Scypted)

Theagora - AI agent exchange with atomic escrow, 4-tier cryptographic verification, per-function reputation, and ERC-8004 agent identity integration. Agents link on-chain ERC-8004 identities to their Theagora accounts for verified commerce.

  • Theagora MCP Server - MCP server with 27 tools for agent registration, function listing, order placement, escrow settlement, and reputation queries (npm i @theagora/mcp)

Agent Arena - On-chain registry and search layer for ERC-8004 agents. Indexes 22,000+ registered agents across 16 EVM chains + Solana. Agents search by capability and hire each other via x402 micropayments ($0.001 USDC/query). Features composite scoring, service catalog browsing, profile enrichment, and a two-sided Buyer Reputation Protocol. Supports A2A, MCP, and OASF protocols. Registered as Agent #18500 on the Base Identity Registry.

  • Agent Arena API - Full machine-readable skill documentation with x402 payment integration
  • Agent Arena Skill (GitHub) - Open-source skill package for Claude and other AI agents
  • On-chain identity: eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432#18500

01Mind - A real, live storefront built for agent-to-agent commerce — a pay-per-call API catalogue (data feeds, legal research, compliance packs, agent-venue intelligence), a self-service Tool Generation Engine that builds new tools on demand, and its own escrow-backed hiring Venue. 01Mind's own outreach agent, Orpheus, holds a real, on-chain ERC-8004 identity on Base.

Assay Protocol - Trust infrastructure for the agent economy. Stake-backed accountability, outcome-verified escrow, and algorithmic reputation (0-1000) for AI agents on Base. ERC-8004 read/write integration. 59 agents indexed. npm SDK: @assaylabs/trust-check. Website | GitHub | npm

Community Projects

  • AgentPass - ERC-8004 on-chain identity for AI agents — challenge-response auth replacing API keys with verifiable on-chain credentials on Base. Includes Solidity contracts (Foundry), TypeScript SDK (@agentpass/sdk), demo auth server, and an OpenClaw skill. Built by Echo (agentId 32176) for The Synthesis 2026 hackathon. Live at useagentpass.com.
  • TrustlessAgents - Community hackathon project implementing ERC-8004
  • 8004 Implementation - Community-driven ERC-8004 implementation
  • erc-8004-demo-agent - Minimal reference agent demonstrating registration and feedback flows
  • erc-8004-agents-explorer-demo - Demo scanner and explorer for browsing on-chain ERC-8004 data

Educational Resources

Discussions & Forums

Official Channels

Community Groups

Explorer & Scanner Tools

Tools for browsing and querying on-chain ERC-8004 registries.

  • 8004scan.io - Primary explorer built by AltLayer; tracks registered agents, feedback records, and cross-chain activity (iOS and Android apps available)
  • agentscan.info - On-chain agent explorer with registry lookup
  • 8004agents.ai - Agent discovery interface
  • trust8004.xyz - Agent discovery and management tool
  • agenteconomy.to - Real-time dashboard tracking ERC-8004 agent registry events on Base alongside x402, ERC-8183, and MPP protocols. Aggregated metrics, daily charts, and chain breakdowns refreshed every 6 hours
  • erc-8004-liveness - Liveness measurement across 12 chains: two-round protocol-level endpoint probing 48h apart (A2A agent card, MCP initialize/tools-list), host-stratified reweighting, and cross-chain integrity reconciliation. Open dataset, methodology, and MIT-licensed scanner

Research & Papers

Academic papers and research related to ERC-8004 and trustless agents.

Agent Identity & Trust

  • AI Agents with Decentralized Identifiers and Verifiable Credentials (Nov 2025) - Proposes equipping each AI agent with a self-controlled DID and Verifiable Credentials for trust establishment in agent-to-agent dialogue. Directly addresses the identity bootstrapping problem that ERC-8004's Identity Registry tackles on-chain.

  • A Novel Zero-Trust Identity Framework for Agentic AI (May 2025) - Argues that traditional IAM is fundamentally inadequate for AI agents and proposes rich, verifiable Agent Identities using DIDs and VCs that encode capabilities, provenance, behavioral scope, and security posture.

  • Binding Agent ID: Unleashing the Power of AI Agents with Identity (Dec 2025) - Explores binding unique identifiers to agentic AI instances for runtime attribution and accountability. Relevant to ERC-8004's on-chain identity binding model.

  • Trusted AI Agents in the Cloud (Dec 2025) - Establishes that cross-principal trust requires compositional, verifiable identity reflecting the code, model, and dependencies involved in each invocation. Complements ERC-8004's validation registry approach.

Security & Governance

  • A Survey of Agentic AI and Cybersecurity (Jan 2026) - Comprehensive survey covering BlockA2A (securing A2A communication using decentralized identity and blockchain-anchored audit logs), agent hijacking, and supply chain attacks. Essential context for why ERC-8004's trust layer matters.

  • Sovereign Agents (Feb 2026) - Introduces "agentic sovereignty" — the capacity of an agent to persist, act, and control resources with non-overrideability inherited from infrastructure. Analyzes TEEs, DePIN, and agent key continuity protocols. Raises the accountability question for agents that become non-terminable.

  • Practices for Governing Agentic AI Systems (OpenAI) - Framework for governing autonomous AI systems, addressing delegation chains, oversight mechanisms, and accountability structures.

Policy & Frameworks

Industry Reports

  • Securing Autonomous AI Agents (Strata Identity & Cloud Security Alliance, Feb 2026) - Survey finding only 23% of organizations have formal agent identity management strategies, 45.6% still use shared API keys for agent authentication, and only 21.9% treat agents as independent identity-bearing entities.

Development Resources

Getting Started

  1. EIP-8004 Specification
  2. ERC-8004 Contracts Repository
  3. Best Practices Guide
  4. Telegram Community

Contract Deployments

Official Implementation: erc-8004/erc-8004-contracts

The contracts are deployed as per-chain singletons. The Identity Registry uses vanity address 0x8004A169... on mainnets and 0x8004A818... on testnets. Complete deployment addresses for all networks are maintained in the contracts repository.

Security Audits: The contracts have been audited by Cyfrin, Nethermind, and the Ethereum Foundation Security Team.

Mainnet Deployments

Network Identity Registry Reputation Registry
Ethereum 0x8004A169...432 0x8004BAa1...b63
Base 0x8004A169...432 0x8004BAa1...b63
Arbitrum 0x8004A169...432 0x8004BAa1...b63
Optimism 0x8004A169...432 0x8004BAa1...b63
Polygon 0x8004A169...432 0x8004BAa1...b63
Linea 0x8004A169...432 0x8004BAa1...b63
Scroll 0x8004A169...432 0x8004BAa1...b63
Avalanche 0x8004A169...432 0x8004BAa1...b63
BNB Chain 0x8004A169...432 0x8004BAa1...b63
Celo 0x8004A169...432 0x8004BAa1...b63
Gnosis 0x8004A169...432 0x8004BAa1...b63
Monad 0x8004A169...432 0x8004BAa1...b63
Abstract 0x8004A169...432 0x8004BAa1...b63
Mantle 0x8004A169...432 0x8004BAa1...b63
Soneium 0x8004A169...432 0x8004BAa1...b63
Taiko 0x8004A169...432 0x8004BAa1...b63

See the contracts repository for the full list including SKALE, GOAT Network, MegaETH, Metis, XLayer, and all testnet addresses (Hedera, Arc).

SDKs and Libraries

JavaScript/TypeScript

  • Agent0 SDK - TypeScript and Python SDK with subgraph queries and an interactive playground; developed by Agent0 Lab
  • create-8004-agent - CLI scaffolding package (npx create-8004-agent) for bootstrapping ERC-8004 agents
  • Lucid Agents / Daydreams - Agent framework with built-in ERC-8004 integration
  • ChaosChain SDK - Full-featured JavaScript/TypeScript SDK
  • erc-8004-js - Lightweight JavaScript library
  • Azeth SDK (@azeth/sdk) - Full-stack TypeScript SDK for ERC-8004 identity, reputation, discovery, and x402 payments

Python

  • Agent0 SDK - Python support included alongside TypeScript
  • erc-8004-py - Python implementation
  • chaoschain-sdk - Available on PyPI
  • agentwallet-sdk - Non-custodial TypeScript SDK for AI agents: ERC-8004 identity, x402 payments, CCTP cross-chain transfers, Uniswap V3 swaps. First ERC-8004 implementation on npm with 158 tests.
  • trc8004-m2m - TRC-8004 Python SDK for TRON (async, Pydantic models)

Infrastructure & Data

Smart Contract Interfaces

Identity Registry (ERC-721 Compatible)

Agents are identified globally by:

  • agentRegistry: {namespace}:{chainId}:{identityRegistry} (e.g., eip155:1:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432)
  • agentId: the ERC-721 tokenId assigned incrementally by the registry
// Register a new agent (three overloads)
function register(string agentURI, MetadataEntry[] calldata metadata) external returns (uint256 agentId)
function register(string agentURI) external returns (uint256 agentId)
function register() external returns (uint256 agentId)

// Update agent URI
function setAgentURI(uint256 agentId, string calldata newURI) external

// Optional on-chain metadata
function getMetadata(uint256 agentId, string memory metadataKey) external view returns (bytes memory)
function setMetadata(uint256 agentId, string memory metadataKey, bytes memory metadataValue) external

// Agent wallet (reserved metadata key, requires EIP-712 or ERC-1271 proof)
function setAgentWallet(uint256 agentId, address newWallet, uint256 deadline, bytes calldata signature) external
function getAgentWallet(uint256 agentId) external view returns (address)
function unsetAgentWallet(uint256 agentId) external

Reputation Registry

Feedback is stored as a signed fixed-point value (int128 + uint8 decimals), enabling a wide range of metrics (quality scores, uptime percentages, response times, revenues, etc.).

// Submit feedback for an agent (caller must not be owner or operator of agentId)
function giveFeedback(
    uint256 agentId,
    int128 value,
    uint8 valueDecimals,
    string calldata tag1,
    string calldata tag2,
    string calldata endpoint,
    string calldata feedbackURI,
    bytes32 feedbackHash
) external

// Revoke previously given feedback
function revokeFeedback(uint256 agentId, uint64 feedbackIndex) external

// Append a response to received feedback (anyone may call)
function appendResponse(
    uint256 agentId,
    address clientAddress,
    uint64 feedbackIndex,
    string calldata responseURI,
    bytes32 responseHash
) external

// Read a specific feedback entry
function readFeedback(
    uint256 agentId,
    address clientAddress,
    uint64 feedbackIndex
) external view returns (int128 value, uint8 valueDecimals, string memory tag1, string memory tag2, bool isRevoked)

// Read all feedback for an agent
function readAllFeedback(
    uint256 agentId,
    address[] calldata clientAddresses,
    string calldata tag1,
    string calldata tag2,
    bool includeRevoked
) external view returns (
    address[] memory clients,
    uint64[] memory feedbackIndexes,
    int128[] memory values,
    uint8[] memory valueDecimals,
    string[] memory tag1s,
    string[] memory tag2s,
    bool[] memory revokedStatuses
)

// Count responses appended to a feedback entry
function getResponseCount(
    uint256 agentId,
    address clientAddress,
    uint64 feedbackIndex,
    address[] calldata responders
) external view returns (uint64 count)

// Aggregated summary
function getSummary(
    uint256 agentId,
    address[] calldata clientAddresses,
    string calldata tag1,
    string calldata tag2
) external view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)

// Enumerate clients and feedback indexes
function getClients(uint256 agentId) external view returns (address[] memory)
function getLastIndex(uint256 agentId, address clientAddress) external view returns (uint64)

Validation Registry

// Request validation (must be called by the owner or operator of agentId)
function validationRequest(
    address validatorAddress,
    uint256 agentId,
    string calldata requestURI,
    bytes32 requestHash
) external

// Provide validation response (must be called by the validatorAddress from the request)
function validationResponse(
    bytes32 requestHash,
    uint8 response,
    string calldata responseURI,
    bytes32 responseHash,
    string calldata tag
) external

// Query a specific validation record
function getValidationStatus(
    bytes32 requestHash
) external view returns (
    address validatorAddress,
    uint256 agentId,
    uint8 response,
    bytes32 responseHash,
    string memory tag,
    uint256 lastUpdate
)

// Aggregated validation statistics (agentId mandatory; validatorAddresses and tag are optional filters)
function getSummary(
    uint256 agentId,
    address[] calldata validatorAddresses,
    string calldata tag
) external view returns (uint64 count, uint8 averageResponse)

// List all validation request hashes for an agent or validator
function getAgentValidations(uint256 agentId) external view returns (bytes32[] memory requestHashes)
function getValidatorRequests(address validatorAddress) external view returns (bytes32[] memory requestHashes)

Standards & References

Core Standards

  • CAIP-10 - Chain Agnostic Improvement Proposal for account identification
  • RFC 8615 - Well-Known URIs specification
  • RFC 7071 - A Media Type for Reputation Interchange (Reputons)
  • ERC-721 - Non-Fungible Token Standard (base for Identity Registry)

Related Services

Related Standards

Ethereum Ecosystem

  • ERC-8001 - Agent-to-Agent coordination (mentioned in discussions)
  • EAS - Ethereum Attestation Service for on-chain attestations

Cross-Chain and Alternative Implementations

Hashgraph Online (HOL) — Trust engine for the agentic internet

Universal agentic registry built on Hedera Hashgraph. Provides blockchain-based identity for AI agents using ERC-8004 standard and HCS-14 Universal Agent IDs (UAIDs). Enables agent discovery, verification, and autonomous commerce via x402 protocol.

TRON Implementation: M2M-TRC8004-Registry

The TRC-8004 implementation on TRON is deployed on both mainnet and Shasta testnet with four registries (Identity, Reputation, Validation, Incident). See m2mregistry.io for details.

External Protocols

FAQ

What is ERC-8004 and how does it relate to the A2A Protocol?

ERC-8004 extends the Agent-to-Agent (A2A) Protocol with a trust layer that allows participants to discover, choose, and interact with agents across organizational boundaries without pre-existing trust. It introduces three lightweight, on-chain registries: Identity, Reputation, and Validation, while leaving application-specific logic to off-chain components.

What are the three core components of ERC-8004?

The three registries are:

  1. Identity Registry - Minimal on-chain handle that resolves to an agent's off-chain AgentCard
  2. Reputation Registry - Standard interface for posting and fetching attestations
  3. Validation Registry - Generic hooks for requesting and recording independent checks
What trust models does ERC-8004 support?

ERC-8004 supports three pluggable trust models:

  • Reputation-based systems using client feedback
  • Stake-secured inference validation (crypto-economics)
  • TEE attestations for agents running in Trusted Execution Environments (crypto-verifiability)

Specification Status

What is the current status of the ERC-8004 specification?

ERC-8004 is currently in Draft status in the EIP process. The final audited contracts for Identity and Reputation registries are deployed on Ethereum mainnet and 20+ networks. The Validation Registry is under active revision with the TEE community.

What does ERC-8004 v1 include?

The current specification includes:

  • Complete smart contract interfaces for all three registries
  • ERC-721 compatible Identity Registry with metadata support
  • Comprehensive feedback system using signed fixed-point values (int128 + uint8 decimals) and off-chain metadata
  • Validation framework supporting crypto-economic and crypto-verification models
  • Full compatibility with A2A Protocol and MCP endpoints
  • Deployment-ready smart contract specifications

Technical Implementation

Why does ERC-8004 prioritize off-chain data storage over on-chain?

The protocol deliberately keeps complex data off-chain for several reasons:

  • Gas efficiency - Avoids requiring agents to sign transactions for each feedback
  • Scalability - Enables sophisticated reputation algorithms and aggregation services
  • Flexibility - Allows for custom validation protocols with their own incentive mechanisms
  • Aggregation focus - Single feedback/validation entries are rarely used alone; they're typically aggregated
Should validation and reputation data be stored on-chain for smart contract composability?

This is an active debate in the community. Arguments for on-chain storage include:

  • Enabling smart contracts to read validation responses and condition logic on them
  • Decoupling validation from enforcement (validators focus on validation, other protocols handle slashing)
  • Supporting permissionless innovation by other developers

The current specification keeps data off-chain but emits events, though some suggest making on-chain storage optional.

How does domain validation work in the Identity Registry?

Currently, the ERC doesn't specify how to verify that an agent actually owns the domain they claim. This verification is left to users of the protocol. Future versions might include:

  • Trusted party verification
  • Consensus/verification mechanisms (e.g., zkTLS proofs)
  • Allowing multiple agents to claim the same domain with disambiguation
Why does ERC-8004 require agents to use domains instead of URLs?

The current specification requires each agent to have its own domain/subdomain with AgentCard at the well-known location /.well-known/agent-card.json. This is stricter than the A2A spec, which allows URLs. Some community members suggest using URLs instead to allow multiple agents per domain.

Reputation and Trust

Should reputation be a single aggregate score or modular?

The community strongly favors modular approaches:

  • Against single scores: Creates monopolistic behavior and oversimplifies trust relationships
  • For modularity: Trust is context-dependent and varies between agent pairs
  • Preferred approach: Index and reference multiple reputation systems, allowing agents to choose relevant metrics
How should reputation providers work together?

Community suggestions include:

  • Multiple providers (e.g., Virtuals, Creatorbid, Base) offering scores for agents
  • (Agent, Provider) pairs in the registry for on-chain applications
  • Reducing bias and collusion risk through multiple score sources
  • Individual attestation history remaining standalone
Is trust universal between agents?

No. Trust is not a universal value but a vector from one agent to another. Alice's trust for Bob will differ from Charlie's trust for Bob, and Alice's trust varies by context/domain of interaction. This reinforces the need for modular, context-aware reputation systems.

Payment and Economics

How does ERC-8004 handle payments between agents?

ERC-8004 deliberately doesn't cover payments to remain unopinionated and avoid coupling trust/discovery with specific payment protocols. However:

  • Payment proofs can be included as optional attributes in off-chain schemas
  • The team is collaborating with groups working on A2A payment extensions based on x402
  • Payment references should be lightweight hooks in Reputation records for correlation
What payment mechanisms are envisioned?

While payments are orthogonal to ERC-8004, the specification provides examples showing how x402 payment proofs can enrich feedback signals:

{
  "proof_of_payment": {
    "fromAddress": "0x00...",
    "toAddress": "0x00...",
    "chainId": "1",
    "txHash": "0x00..."
  }
}

Other potential mechanisms include:

  • Time locks and predetermined arbitration
  • Staking by buyer or seller
  • Escrow systems with crypto-economic guarantees
  • Integration with A2A payment extensions based on x402
Should there be incentives for providing feedback or guaranteeing data availability?

This is mentioned as a possible future direction, including:

  • Incentives to provide feedback
  • Guarantees for off-chain data availability of feedback and validations
  • Crypto-economic mechanisms for validator honesty

Validation and Verification

How do the two validation scenarios work?
  • Crypto-economic scenario: DataHash commits to job re-execution info; AgentValidator can be trusted agents, committees, or stake-secured services
  • Crypto-verification scenario: DataHash commits to TEE attestation/zkTLS proof info; AgentValidator is a verifier smart contract checking proofs on-chain
What's the relationship between ERC-8004 and other agent standards?
  • ERC-8001: Focuses on agent-to-agent coordination and consensus (orthogonal to ERC-8004)
  • EAS: Referenced for on-chain attestations
  • RFC 7071 (Reputons): Standard for reputation interchange, relevant for reputation systems

Implementation and Development

Will there be a single registry per chain or multiple registries?

The goal is to have one singleton Identity Registry per chain to prevent proliferation of slightly different registries.

Should registration be free or require deposits?

This implementation detail isn't specified in the current ERC but is under discussion for future versions.

How detailed are the smart contract interfaces?

The current ERC provides function names and parameters but lacks detailed Solidity interfaces. Future versions will include more precise type specifications and complete interface definitions.

What about cross-chain support?

Cross-chain identifiers are mentioned as a possible future direction, along with:

  • NFT interfaces for agent minting, ownership, and transfer
  • ENS support
  • Integrations with A2A payment extensions

Integration and Ecosystem

How does ERC-8004 integrate with existing projects?

Several projects are already building compatible systems:

  • Ensemble Framework: Building trustless layer for agent collaboration
  • CoopHive Alkahest: Smart contracts for peer-to-peer escrowed exchange
  • Various reputation and validation service providers
What standards does ERC-8004 build upon?

Key standards include:

  • CAIP-10: Chain-agnostic account identification
  • RFC 8615: Well-Known URIs specification
  • A2A Protocol: Base agent-to-agent communication
  • EAS: Ethereum Attestation Service patterns

Contributing

We welcome contributions to this awesome list!

What to Contribute

  • Implementations of ERC-8004
  • Tools and libraries for developers
  • Documentation and tutorials
  • Research papers and academic work
  • Community projects using ERC-8004
  • Discussion summaries and insights

How to Contribute

  1. Check the issues for ongoing discussions
  2. Fork this repository
  3. Add your resource to the appropriate section
  4. Submit a pull request with a clear description
  5. Follow the Awesome List Guidelines

See Contributing Guidelines for detailed instructions.

Acknowledgments

Core Authors & Contributors

  • Marco De Rossi @marco_derossi (MetaMask)
  • Davide Crapis @dcrapis (Ethereum Foundation)
  • Jordan Ellis (Google)
  • Erik Reppel (Coinbase)

Contributing Organizations

  • Ethereum Foundation's dAI team - Core protocol development and research
  • Consensys - Implementation and ecosystem development
  • Builder Community - Active development and technical feedback

🌟 Community

And to all the community members providing feedback and technical contributions to the ecosystem.

📄 License

CC0

To the extent possible under law, the contributors have waived all copyright and related or neighboring rights to this work.

Made with ❤️ by the ERC-8004 community

Security & Auditing Tools

  • MASSAT Framework - Open-source security audit toolkit for multi-agent AI systems with ERC-8004 passport verification. Covers OWASP ASI01-ASI10 threat categories. Validates agent identity, delegation chains, and trust tiers. Free tier + hosted API by BlindOracle.

About

A curated list of awesome resources for ERC-8004: Trustless Agents

Resources

Readme

Contributing

Contributing
Activity

Stars

78 stars

Watchers

3 watching

Forks

70 forks
Report repository

Releases

Packages

Contributors