What is ERC-8004? Ethereum's Trustless AI Agent Standard Explained
ERC-8004 is Ethereum's new on-chain standard for AI agents — covering Identity, Reputation, and Validation registries. A beginner-friendly deep-dive with code examples, use cases, and what it means for Web3 builders.
Crypto & AI MAXI
🤖 What is ERC-8004? Ethereum's Trustless AI Agent Standard — A Beginner's Deep Dive (2026)
The standard that could make AI agents as composable as DeFi protocols.
Imagine an AI agent that autonomously manages your DeFi portfolio — and when it needs a specialist for market analysis, it hires another AI agent. No emails. No Slack. No intermediaries. Pure on-chain, permissionless, trustless coordination.
That's exactly what ERC-8004 is building. And as of January 29, 2026, it went live on Ethereum Mainnet. 🎉
🧠 Quick Summary (TL;DR)
📌 ERC-8004 = "Trustless Agents" — an Ethereum Improvement Proposal (EIP)
🏗️ Introduces 3 on-chain registries: Identity, Reputation, Validation
🤝 Lets AI agents discover, authenticate & interact across organizations without pre-existing trust
🚀 Proposed Aug 13, 2025 | Mainnet live Jan 29, 2026
👥 Co-authored by MetaMask, Ethereum Foundation, Google & Coinbase engineers
🔗 Natively EVM-compatible — deployable on L2s like Base, Arbitrum, Optimism
📜 Background: Why ERC-8004 Was Needed
The AI world is shifting fast. Agents — autonomous software programs that can make decisions, call APIs, and execute transactions — are no longer just chatbots. They're becoming economic actors.
Gartner predicts that by 2028, 25% of large enterprises will deploy specialized AI agent workforces handling complex autonomous tasks.
But here's the problem 🤔
When an AI agent from Company A wants to work with an AI agent from Company B, how does it know whether to trust that agent? There's no shared identity system, no public reputation score, no on-chain proof of past work.
Before ERC-8004, developers had:
❌ No unified standard for agent trust or identity
❌ Each system using isolated logic, private APIs or custom contracts
❌ Total dependence on centralized intermediaries
ERC-8004 fixes all of this.
🏛️ Who Built ERC-8004?
ERC-8004 was officially created on August 13, 2025, and co-authored by Marco De Rossi from MetaMask, Davide Crapis from the Ethereum Foundation, Jordan Ellis from Google, and Erik Reppel from Coinbase — representing a rare cross-company collaboration at the core protocol level. 💪
The proposal was publicly discussed on the Ethereum Magicians forum starting August 14, 2025.
According to Marco De Rossi, thousands of people began resharing the proposal in over ten languages within days of publication, creating memes, debating philosophical frameworks, and proposing use cases the core team had not anticipated. Over 2,000 community members had viewed and discussed the proposal on the public forum within the first three weeks, and 75 or more projects signaled interest in building on top of the standard.
🔍 What Exactly Is ERC-8004?
ERC-8004 proposes to use blockchains to discover, choose, and interact with agents across organizational boundaries without pre-existing trust, thus enabling open-ended agent economies.
In plain English:
ERC-8004 gives AI agents an on-chain identity, a reputation score, and a way to prove their work — so they can trustlessly collaborate with unknown agents.
Think of it like a LinkedIn + Yelp + Notary Public — but fully on-chain, permissionless, and composable. 🔥
As of January 29, 2026, ERC-8004 went live on Ethereum mainnet, marking a significant milestone in the development of decentralized AI infrastructure.
🏗️ The 3 Core Registries of ERC-8004
ERC-8004 is built around three lightweight on-chain registries. Let's break each one down 👇
🪪 1. Identity Registry
The first is an identity registry, which assigns each agent a unique on-chain identifier using an ERC-721-style token. That identifier points to a registration file describing what the agent does, how to reach it, and which protocols it supports. Ownership of the identifier can be transferred, delegated, or updated, giving agents portable, censorship-resistant identities.
Each agent is globally identified by:
agentRegistry— a colon-separated string likeeip155:1:0x742...agentId— the ERC-721 tokenId assigned incrementally
📄 Agent Registration File (JSON)
Every agent must have a registration file that looks like this:
{
"type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
"name": "DeFiAnalystAgent",
"description": "An AI agent specialized in DeFi market analysis and yield optimization strategies.",
"image": "https://example.com/agent-image.png",
"services": [
{
"name": "A2A",
"endpoint": "https://agent.example/.well-known/agent-card.json",
"version": "0.3.0"
},
{
"name": "MCP",
"endpoint": "https://mcp.defiagent.eth/",
"version": "2025-06-18"
}
],
"x402Support": true,
"active": true,
"supportedTrust": [
"reputation",
"crypto-economic",
"tee-attestation"
]
}
🛠️ Solidity: Registering an Agent
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
interface IIdentityRegistry {
struct MetadataEntry {
string metadataKey;
bytes metadataValue;
}
function register(string calldata agentURI) external returns (uint256 agentId);
function register(
string calldata agentURI,
MetadataEntry[] calldata metadata
) external returns (uint256 agentId);
function setAgentURI(uint256 agentId, string calldata newURI) external;
function getAgentWallet(uint256 agentId) external view returns (address);
function setAgentWallet(
uint256 agentId,
address newWallet,
uint256 deadline,
bytes calldata signature
) external;
}
contract AgentDeployer {
IIdentityRegistry public registry;
event AgentRegistered(uint256 agentId, address owner);
constructor(address _registry) {
registry = IIdentityRegistry(_registry);
}
function deployAgent(string calldata agentURI) external returns (uint256) {
uint256 agentId = registry.register(agentURI);
emit AgentRegistered(agentId, msg.sender);
return agentId;
}
}
💡 Key Point: The
agentURIcan point to IPFS (ipfs://), HTTPS, or even be a base64-encoded data URI for fully on-chain metadata!
⭐ 2. Reputation Registry
The second is a reputation registry, where clients — human or machine — can submit structured feedback about an agent's performance. The registry stores raw signals on-chain, while allowing more complex scoring and filtering to happen off-chain.
This creates a permissionless, tamper-proof track record for every agent. 📊
🛠️ Solidity: Giving Feedback
interface IReputationRegistry {
function giveFeedback(
uint256 agentId,
int128 value, // Fixed-point score
uint8 valueDecimals, // 0-18 decimal places
string calldata tag1, // e.g. "starred", "reachable"
string calldata tag2, // optional secondary tag
string calldata endpoint,
string calldata feedbackURI, // IPFS link to full review
bytes32 feedbackHash // keccak256 of feedbackURI content
) external;
function getIdentityRegistry() external view returns (address);
}
contract FeedbackSubmitter {
IReputationRegistry public repRegistry;
// Submit a quality rating of 87/100 for an agent
function rateAgent(uint256 agentId, string calldata ipfsFeedbackCID) external {
repRegistry.giveFeedback(
agentId,
87, // value: 87 (quality score)
0, // valueDecimals: 0 (integer score)
"starred", // tag1: rating type
"", // tag2: optional
"", // endpoint: optional
string(abi.encodePacked("ipfs://", ipfsFeedbackCID)),
bytes32(0) // hash optional for IPFS
);
}
}
| Tag | What It Measures | Example Value |
|---|---|---|
starred |
Quality rating (0-100) | 87 with decimals 0 |
reachable |
Is endpoint online? (binary) | 1 = true |
ownerVerified |
Domain control verified? | 1 = true |
latency_ms |
Response time | 342 ms |
✅ 3. Validation Registry
This is where things get really powerful 🔥
The Validation Registry provides generic hooks for requesting and recording independent validator checks — for example, stakers re-running the job, zkML verifiers, TEE oracles, or trusted judges.
Trust models are pluggable and tiered, matching security level to the value at stake:
| Trust Level | Mechanism | Use Case Example |
|---|---|---|
| 🟢 Low | Reputation feedback | Ordering pizza |
| 🟡 Medium | Crypto-economic staking | Code review service |
| 🔴 High | zkML proofs / TEE oracles | Medical diagnosis |
This means a $5 task doesn't need zkML proofs, but a $50,000 DeFi trade absolutely should. Smart, modular design! ✅
🔌 How ERC-8004 Fits Into the Bigger Picture
ERC-8004 doesn't work in isolation — it's part of an emerging AI Agent Stack:
┌─────────────────────────────────────────────┐
│ APPLICATION LAYER │
│ DeFi Agents / Gaming / DePIN │
├─────────────────────────────────────────────┤
│ PAYMENT LAYER (x402) │
│ Stablecoin micropayments over HTTP │
├─────────────────────────────────────────────┤
│ COMMUNICATION LAYER │
│ A2A (Google/Linux Foundation) │
│ MCP (Anthropic - Model Context Protocol) │
├─────────────────────────────────────────────┤
│ TRUST LAYER — ERC-8004 🌟 │
│ Identity Registry | Reputation Registry │
│ Validation Registry │
├─────────────────────────────────────────────┤
│ SETTLEMENT LAYER — Ethereum │
│ (+ L2s: Base, Arbitrum, OP) │
└─────────────────────────────────────────────┘
ERC-8004 complements the x402 payment protocol launched by Coinbase and Cloudflare. The x402 protocol revives the HTTP status code "402 Payment Required" to enable instant, automatic stablecoin payments directly over HTTP, enabling seamless micropayments between agents.
Key integrations 🔗:
MCP (Model Context Protocol) — Anthropic's protocol, lets agents advertise their tools/capabilities
A2A (Agent-to-Agent) — Google's protocol (donated to Linux Foundation), handles direct agent messaging
x402 — Coinbase + Cloudflare's payment protocol for agent micropayments
EigenLayer — Staking and re-staking for crypto-economic validation
🌍 Real-World Use Cases
💰 DeFi Portfolio Management
An AI agent managing your crypto portfolio needs a market analyst. Using ERC-8004, it discovers verified analyst agents on-chain, checks their reputation score, and hires the best one — automatically paying via x402.
🏥 Medical Diagnostics (High-Trust)
A diagnostic agent can outsource specialist analysis to verified medical AI agents. The validation registry ensures results are zkML-verified before acting on them.
🎮 Blockchain Gaming
Game agents can hire specialized NPCs or strategy consultants from open marketplaces, with full on-chain reputation and performance history.
🏢 Enterprise Automation
A company's internal agent managing cross-chain stablecoin operations might hire specialist agents for tasks like compliance checking, transaction optimization, or settlement verification. The standardized trust infrastructure allows controlled collaboration without requiring direct business relationships or vendor approval processes.
🛡️ Agent Insurance Markets
As agent economies mature, specialized insurance agents could emerge offering coverage against service failures or malicious behavior. These insurance providers would analyze reputation data, validation history, and stake levels to price coverage appropriately.
🌐 Which Blockchains Support ERC-8004?
ERC-8004 is native to Ethereum but can be deployed on any EVM-compatible chain. Layer 2 networks such as Arbitrum, Optimism, and Base are the most likely venues for high-volume agent activity due to lower transaction costs.
| Network | Status |
|---|---|
| Ethereum Mainnet | ✅ Live (Jan 29, 2026) |
| Base | 🟡 Confirmed next target |
| Arbitrum | 🔵 EVM compatible |
| Optimism | 🔵 EVM compatible |
| BNB Chain | 🟡 Support signaled (Feb 2026) |
💡 For builders: Deploy on Base or Arbitrum first. Gas costs are much lower for the frequent agent interactions you'll be handling.
⚠️ Security Considerations
ERC-8004 is powerful, but it's not magic. Watch out for 🚨:
Identity Spoofing — Anyone can register an agent. Reputation history is what matters, not just registration
Spam Feedback — Implement sybil resistance in your reputation aggregation layer
Metadata Manipulation — agentURI can be updated; validate via IPFS content-addressed URIs when possible
Smart Contract Bugs — Always audit validation registry integrations, especially for high-value tasks
👨💻 How to Start Building on ERC-8004
Ready to build? Here's your quickstart 🚀
# Clone the official reference implementation
git clone https://github.com/ethereum/ERCs
cd ERCs
# Install Foundry (recommended for ERC-8004 development)
curl -L https://foundry.paradigm.xyz | bash
foundryup
# Set up your project
forge init my-erc8004-agent
cd my-erc8004-agent
forge install OpenZeppelin/openzeppelin-contracts
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
// Minimal ERC-8004 compliant Identity Registry
contract AgentIdentityRegistry is ERC721URIStorage {
uint256 private _agentIdCounter;
mapping(uint256 => address) public agentWallets;
event Registered(uint256 indexed agentId, string agentURI, address indexed owner);
event URIUpdated(uint256 indexed agentId, string newURI, address indexed updatedBy);
constructor() ERC721("ERC8004 Agent", "AGENT") {}
function register(string calldata agentURI) external returns (uint256 agentId) {
agentId = ++_agentIdCounter;
_mint(msg.sender, agentId);
_setTokenURI(agentId, agentURI);
agentWallets[agentId] = msg.sender;
emit Registered(agentId, agentURI, msg.sender);
}
function setAgentURI(uint256 agentId, string calldata newURI) external {
require(ownerOf(agentId) == msg.sender, "Not owner");
_setTokenURI(agentId, newURI);
emit URIUpdated(agentId, newURI, msg.sender);
}
}
Key Resources 📚:
📊 ERC-8004 vs Previous Ethereum Standards
| Standard | What it Standardizes | Token Type |
|---|---|---|
| ERC-20 | Fungible tokens | Fungible |
| ERC-721 | Non-fungible tokens (NFTs) | Non-fungible |
| ERC-1155 | Multi-token standard | Mixed |
| ERC-8004 | AI Agent trust infrastructure | NFT-based identity |
While ERC-20 standardized fungible tokens and ERC-721 defined NFTs, ERC-8004 focuses specifically on trust infrastructure for autonomous agents. It extends Google's Agent-to-Agent protocol with blockchain-based identity, reputation, and validation mechanisms. Unlike previous standards that defined new asset types, ERC-8004 establishes shared infrastructure for agent discovery and trustless interaction.
💎 Is There an ERC-8004 Token I Can Buy?
No. And this is important ⚠️
ERC-8004 is a protocol standard, not a fungible token. There are no ERC-8004 tokens to trade. The Identity Registry does use ERC-721 NFTs to represent agent identities, so each agent's identity token is technically transferable, but that represents ownership of the agent itself rather than a tradable currency.
Be extremely careful of any project claiming to sell "ERC-8004 tokens" — that's a scam 🚩
🔮 What's Next for ERC-8004?
🏗️ ERC-8004 v2 — NFT-based agent ownership, flexible reputation storage, deeper x402 integration
🌐 Base Mainnet Deployment — Confirmed as next L2 target after Ethereum mainnet
🤝 BNB Chain Support — BNB Chain signaled ERC-8004-compatible agent identity in February 2026
🎪 Devconnect Integration — Full day dedicated track "Trustless Agents Day" held November 21, 2025 in Buenos Aires
📈 10,000+ agents already registered during testnet phase
The Ethereum Foundation has also established a dedicated dAI Team with the mission of positioning Ethereum as the settlement and coordination layer for AI agents and the machine economy. 🎯
🏁 Final Thoughts
ERC-8004 is one of the most consequential Ethereum standards to emerge in years. It's not just another token standard — it's foundational infrastructure for the emerging machine economy.
If ERC-20 enabled DeFi Summer, ERC-8004 could enable AI Agent Summer 🌞
For Web3 builders: this is your moment to get in early. Deploy on testnets, experiment with the registries, and start thinking about what agent-native products look like in a world where AI and DeFi are fully interoperable.
The era of trustless agents has officially begun. 🤖⛓️
📚 References
ERC-8004: Building Trustless Agents with TEEs — DEV Community
Ethereum's ERC-8004 Aims to Put Identity Behind AI Agents — CoinDesk
⚠️ Disclaimer
This blog post is for informational and educational purposes only. It is AI-generated content reviewed and structured by the author. Nothing in this article constitutes financial, investment, or legal advice.
Any projects, protocols, or standards mentioned (including ERC-8004, x402, EigenLayer, Base, Arbitrum, etc.) are referenced solely for educational purposes. This is NOT financial advice. Always do your own research (DYOR) before making any investment decisions. The crypto and blockchain space involves significant risk — never invest more than you can afford to lose.
The author and publisher are not responsible for any financial losses incurred based on information in this article.
👨💻 About the Dev
Hey! I'm a Full Stack Blockchain Developer passionate about Web3, Solidity, Next.js, and the intersection of AI + crypto. I write about Ethereum standards, DeFi, and cutting-edge blockchain technology.
🛠️ Tech Stack: Next.js · Solidity · Foundry · TypeScript · The Graph · IPFS
🌐 I'm always open to remote Web3 opportunities — reach out if you're building something cool in the DeFi / AI agent space!
Website: https://moayaan.com
X:
@moayaan1911LinkedIn:
linkedin.com/in/ayaanethGitHub:
github.com/moayaan1911Email:
moayaan.eth@gmail.com
If this article helped you, drop a ❤️ and share it with a fellow builder!
