通過 SOC 2 Type II 認證 · ISO 27001

AI agents can generate code, execute workflows, and interact with external services.

Finding new tools remains much harder.

Most agents rely on integrations that were configured beforehand, whether through prompts, frameworks, APIs, or marketplaces. As the number of agent-accessible services grows, that approach becomes difficult to scale.

ERC-8257 promises a permissionless way to discover and verify agentic tools and services.

This blog explains what ERC-8257 is, how an agent tool registry works, how it fits into the overall agentic infra stack, and what capabilities this registry unlocks.

What is ERC-8257

ERC-8257 (Agent Tool Registry) is a draft Ethereum standard that defines a permissionless onchain registry for AI agents and tools. It standardizes a minimal, verifiable record of what a tool is, who published it, and who's allowed to call it.

In April 2026, Cody Sears and Ryan Ghods at OpenSea proposed this standard to allow AI agents to autonomously discover, purchase access to, and invoke tools.

How ERC-8257 Works

Each registered tool or ERC-8257 compatible agent will have an onchain record of 3 components:

1. Creator address: the publisher, permanently bound at registration

2. Metadata URI: a pointer to the tool's offchain manifest

3. Manifest hash: verifies that description has not changed

And an optional fourth component in access predicate which is a contract address that decides who can call the tool.

Together, these create a shared source of truth for tool metadata with one guarantee: the manifest you fetched is the one the creator committed, from the origin they control, under the address they signed with.

Having understood the purpose and components living within the agent tool registry, let's learn how they all work together and what the flow is like.

There are two workflows within ERC-8257, namely:

1. Registry Flow: Interaction between publisher and registry.

2. Discovery and Verification Flow: Interplay between agents, registry, and tools.

Let's understand each individually.

ERC-8257: How the Registry Flow Works

The registry flow governs how a tool gets published and made discoverable. A publisher registers the tool's creator address, metadata URI, and manifest hash (plus an optional access predicate), creating the onchain record that agents can later resolve and verify.

ERC-8257: How the Discovery and Verification Works

When an agent finds a tool or a service, this discovery and verification process establishes trust in the metadata the agent is reading.

The registry's role ends once the agent has verified that the manifest, publisher, and access requirements match the registered record.

Until now, ERC-8257 seems like a generic registry, but the optional predicate section is where ERC-8257 becomes more than a registry.

ERC-8257 Access Control: The Predicate Pattern Explained

The agent tool registry solves for discovery and verification. But, not every tool should be callable by every agent or be entirely public.

Some services may require a subscription. Others may be restricted to NFT holders, enterprise customers, or agents that meet specific reputation requirements.

ERC-8257 solves access with an optional component called an access predicate: an external contract that decides whether a caller can use a tool.

What is Predicate-Based Access Control

An access predicate is a contract address attached to a tool registration.

When an agent attempts to use a tool, it can call the predicate contract and ask a simple question: Is this caller allowed to access this tool?

Now, the predicate contract can check whether an agent owns an NFT, holds a subscription token, has paid for access, belongs to an allowlist, or satisfies a reputation requirement.

Different tools can implement different policies without requiring changes to the registry itself. Here are a few examples:

Most importantly, ERC-8257 doesn't hardcode any of those rules, it lets the predicate contract be an optional add-on, keeping the standard lightweight while also keeping it extensible for a multitude of use cases.

We now know what agent tool registry is, how it gets registered, how agents discover it, and how access is controlled. Next, what can you build with this?

What ERC-8257 Unlocks

A registry by itself is not particularly interesting.

DNS became important because websites could be discovered through it. Package registries became important because software could depend on them. App stores became important because they connected users to applications.

ERC-8257 creates a discovery layer for agent-accessible tools. Let's explore a bunch of capabilities that are unlocked because of this:

1. Agentic Marketplaces

Every tool has verifiable provenance, programmable access, and onchain pricing hints. That's enough to build a marketplace where tools are discovered, accessed, and traded without a platform operator mediating any of it.

2. Programmable Access Markets

A tool provider can define pricing, subscriptions, token ownership requirements, reputation thresholds, or enterprise permissions through the predicate contract. This flexibility allows different access models to compete while remaining interoperable at the discovery layer.

3. Composable Agent Workflows

Multi-step agent pipelines where each tool is independently verified and gated is now possible with ERC-8257.

For instance, a trading agent can be tied with a 24/7 news scrapper tool or a prediction market agent can be linked with a Twitter (X) agent.

ERC-8257 provides a standard way to discover and verify those dependencies, making multi-agent workflows easier to compose across independent providers.

4. Open Agent Ecosystems

Every platform eventually faces the same challenge: maintaining its own directory of services.

ERC-8257 shifts that responsibility into shared infrastructure. Tool providers publish once. Agent frameworks, wallets, marketplaces, and applications consume the same records.

5. Cross-Organizational Agent Workflows

Most agent workflows today operate within a single organization or platform.

ERC-8257 paves the way for cross-organization workflows like vendor-client, client-marketplace, and more.

For instance, a research agent could purchase access to proprietary data feeds exposed through registered tools.

ERC-8257's working and capabilities are now understood. What's next is understanding the broader agent stack required to help agents actually work.

Where ERC-8257 Sits in the Agentic Infrastructure Stack

ERC-8257 solves one specific problem within the broader agent stack: capability discovery and verifiable interaction.

But, agents still need identity, execution environments, payment rails, and coordination to interact.

Let's put together the stack now.

With this lens, ERC-8257 looks less like an AI standard and more like infrastructure.

• A registered tool may expose an MCP server.

• A predicate may require payment before access is granted.

• An agent identity standard may be used to prove who is making the request.

None of those responsibilities belong to ERC-8257 itself.

The standard's role is to answer a simpler question: "What capabilities are available and where can they be found?"

Now, the architecture is sound so is the design choice. The open questions are about adoption.

What's Next for ERC-8257

Most software today is built around direct integrations.

A developer chooses a service, reads its documentation, writes code against its API, and maintains that relationship over time.

ERC-8257 does not further this but pushes agentic infrastructure in a different direction.

• Capabilities become discoverable at runtime.

• Access policies become programmable.

• Services can be consumed without human approval.

ERC-8257 is a common discovery layer. That may seem like a small piece of infrastructure.

DNS was a small piece of infrastructure. Package registries were a small piece of infrastructure. App stores began as directories.

The harder challenge lies ahead.

How should agents evaluate reputation? How should marketplaces rank tools? What standards should govern payments, subscriptions, or revenue sharing between autonomous systems? How should organizations expose internal capabilities without compromising security?

ERC-8257 does not answer the questions. It starts the dialogue and solution path.

FAQs (Frequently Asked Questions)

1. How does ERC-8257 work?

A provider registers a tool by publishing a creator address, metadata URI, manifest hash, and optional access predicate. Agents retrieve the manifest, verify it against the onchain record, evaluate any access requirements, and then invoke the tool.

2. What is an ERC-8257 manifest?

A manifest is a machine-readable description of a tool. It contains metadata such as capabilities, endpoints, usage requirements, and other information agents need to understand and interact with the service.

3. Is ERC-8257 only for AI agents?

No. Any machine-accessible service can be registered through ERC-8257. While the standard was designed with AI agents in mind, APIs, software services, automation systems, and other programmable applications can use the same discovery model.

4. How is ERC-8257 different from MCP?

MCP standardizes how tools are exposed and invoked. ERC-8257 standardizes how tools are discovered and verified. The two are complementary and can be used together within the same agent architecture.

5. What can developers build with ERC-8257?

Developers can build agent marketplaces, programmable access systems, cross-organizational agent workflows, service discovery layers, and multi-agent ecosystems on top of a shared registry standard.

6. Is ERC-8257 live on mainnet?

Yes. The ToolRegistry contract is deployed at 0x265BB2DBFC0A8165C9A1941Eb1372F349baD2cf1 on Ethereum mainnet and Base. As of mid-2026, 76 tools are indexed. The EIP remains in Draft status, meaning the interface can still change before finalization.

7. Does ERC-8257 store tool metadata onchain?

No. The registry stores references to metadata rather than the metadata itself. Tool descriptions remain offchain, while hashes stored onchain allow agents to verify their integrity.