AI on Arbitrum: Establishing an Agent Registry with ERC-8004

From assistants that generate art or write emails to agents that execute DeFi strategies, every week AI tools are used to help automate everyday processes. What began as isolated helpers is now evolving into connected workflows capable of completing entire tasks from start to finish, with minimal human input. The next step in that evolution is even more interesting: agent-to-agent communication. Instead of waiting for human prompts, agents are starting to coordinate, exchange information, and make collective decisions.

One of the first steps toward solving trust and discoverability is ERC-8004, a new Ethereum standard proposal that defines how agents can be registered, discovered, and verified onchain. ERC-8004 introduces a public registry system, a space where agents can record task results and build a verifiable reputation over time.

In this article, we'll analyze the architecture of ERC-8004 and share key insights on how developers can leverage this new standard to start building their next-generation applications.

The Three Pillars of the Agentic Economy: A Conceptual Framework

For this agent-to-agent world to operate at scale, three distinct, composable foundations need to be defined: 

1. Communication: A standardized protocol for agents to interoperate and exchange task-specific information. Google's A2A protocol serves this function.   
2. Payment: A mechanism for agents to pay and receive payment for services, such as the x402 protocol (which activates the HTTP 402 "Payment Required" status code for onchain transactions). You can learn more in this curated article.
3. Trust: A system for agents to discover each other, verify identities, and build a verifiable reputation. This is the gap that ERC-8004 is designed to fill.   

The primitive: Do not trust, verify

Imagine Bob, an autonomous LLM agent with delegated funds, searching for another agent to perform a token swap from USDC to ARB.
Alice, Bob’s creator, discovers Charlie, a swap agent that claims to optimize trades using Arbitrum’s Timeboost feature. Alice chooses Charlie and manually hard-codes the connection between Bob and Charlie, creating a flow where each time Alice asks for a swap, it is automatically executed through the actors.

This works, but only for a while. What happens when new agents appear with better strategies, lower fees, or improved efficiency? In the current setup, Bob would never know.

The concept of autonomous AI agents coordinating to execute complex tasks creates a critical gap. In a closed network, an agent can trust that "Agent B" is what it claims to be. In an open, permissionless "Agentic Economy," an agent has no such guarantee. This environment demands a public, verifiable, and trust-minimized infrastructure for agents to discover, identify, and validate one another before engaging in high-stakes interactions. 

The logical next step would be to allow Bob to discover and evaluate new agents dynamically. However, to do this safely, we cannot rely on the current mechanism of "trusting what the publisher claims." We need a system that follows the true onchain principle: "don't trust, verify." This is where ERC-8004 changes the game. Its fundamental proposal is the creation of a global, standardized registry. Thanks to this registry, an agent like Bob no longer depends on a static connection. It can actively query this registry.

AI KISSes Blockchain: Breaking Down ERC-8004’s Architecture

The beauty of ERC-8004 lies in the KISS principle: "Keep it simple, stupid."

It defines just three lightweight registries, yet together they describe a system of discovery, validation, and reputation.

1. Identity Registry: This establishes a global, onchain namespace for agents by extending the familiar ERC-721 (NFT) standard. 
   Each registered agent is minted as a unique NFT, whose metadata points to different attributes (Agent Card, MCP server, OASF, DID, wallet address, etc). This makes agent identity a unique, ownable, transferable, and verifiable onchain asset.

Here you have a code example on how to register (mint) an agent:

• Reputation Registry: This is a minimal, lightweight interface for posting and fetching attestations. As an agent accepts a task, it’s expected to sign a feedbackAuth to authorize the client (human or agent) to give feedback. The feedback consists of a score (0-100), tag1 and tag2 (left to developers’ discretion to provide maximum onchain composability and filtering); the standard deliberately leaves the subjective interpretation of this raw data to a permissionless market of offchain reputation providers.

• Validation Registry: It provides a standardized framework for requesting and recording independent verification of an agent's work. This registry is "pluggable," allowing validators to use diverse, modular methods based on the task's security needs. These can range from crypto-economic models like "stake-secured inference re-execution," to cryptographic validation using Trusted Execution Environments (TEEs), to advanced Zero-Knowledge Machine Learning (zkML) verifiers, or even optimistic and social validation for other tasks.

Onchain Validation is for Stylus

Stylus introduces a parallel virtual machine (based on WASM) that runs alongside the traditional EVM, allowing developers to write contracts in high-performance languages like Rust and C++. The primary benefits are a dramatic reduction in gas costs for computation and memory.

This capability has profound implications for the ERC-8004. As we've discussed, the standard is intentionally minimal, leaving complex, subjective, and compute-intensive tasks (like reputation scoring and deep validation) to the application layer. On the standard EVM, this means most of a "validator's" heavy lifting might happen offchain, with the blockchain only acting as a simple registry or "proof-anchoring" layer.

Here are two core examples of what this enables:

• Reputation Algorithm: Calculating a real, trustworthy reputation requires running complex, weighted algorithms (like EigenTrust) to filter this noise. Now is the moment for a Stylus solution that reads recent attestations from the Reputation Registry and executes a sophisticated graph analysis or trust algorithm to filter noise and score the agent's reputation.

Clients (like Bob's agent from our earlier example) could then query this onchain score instead of relying on a raw, trusted offchain record.

• Onchain validation: On the standard EVM, a validator contract is computationally restricted and limited to "proof-anchoring", where the real validation happens offchain and only the result is posted onchain. Now we can use Stylus for these compute-intensive tasks, like verifying a complex zkML proof, re-running lightweight models, and combining this logic with slashing mechanisms on the agent's staked collateral. This transforms the Validation Registry from a simple anchoring system into a true "onchain verifiable execution" system.

Critical Challenges & Building Opportunities

ERC-8004 is a minimal standard by design, leaving sophisticated implementations to the application layer. This means the ecosystem builders can empower this modular architecture and manage the complexity to order to improve security and decentralization. The standard is still under review and is a hot topic among the community builders. This means it's the moment to build solutions on top to address potential critical challenges:

• The Sybil Problem: The standard lacks a native defense against "duplication," where an attacker mass-registers agents to collude and inflate their reputations.
• Transferable Reputation Risk: Since the ERC-721 identity is transferable, a malicious actor could buy a high-reputation agent and replace its honest code with a fund-draining script.
• Privacy Concerns: The public nature of the registry could expose sensitive data about client tasks or proprietary agent strategies.
• The "Past Performance" Fallacy: As the financial disclaimer goes, "past performance is no guarantee of future results." A good onchain reputation is a historical data point, not a promise an agent won't fail.

Solving these challenges—building complex Sybil filters, robust validator agents with slashing mechanisms, or a privacy-preserving layer for reputation registries—could possibly be blocked by high onchain gas costs. This is the exact barrier where execution environments like Arbitrum's Stylus are designed to break. It makes these compute-intensive solutions economically viable onchain for the first time.

We would love to hear more ideas where Stylus could help enhance the decentralization and security of ERC-8004. What ideas sparked in your mind while reading the article?

My DMs are open, keen to talk about you ideas and hear what you're building 🤝

The Foundation for a Verifiable Agent Economy

ERC-8004 is a foundational primitive for AI. By design, it is a lightweight standard that provides the essential, "trust-minimized rails" for an open machine economy. It elegantly solves the problem of agent identity, ownership, and discovery, while intentionally leaving the complex, subjective tasks of reputation scoring and validation specific to the agents' purpose.

This is where its synergy with Arbitrum Stylus becomes so powerful. It can provide the compute engine and the tools to mitigate the critical challenges and build the next layer of applications, starting with fully-fledged validators, incentives, and slashing mechanisms.

Together, these technologies lay a robust foundation for the next generation of trustless, autonomous, and economically viable AI onchain.