Agent0 Subgraphs Are Live: Query the Open Agent Economy Across 5 Chains

The Data Layer for the Agent Economy: Agent0 Subgraphs Are Live and Thriving on Base, BNB Chain, Ethereum, Monad, and Polygon

The Graph is now indexing every ERC-8004 trustless agent across five major networks, giving developers millisecond-fast discovery, reputation, and capability search for the open agent economy.

Check out The Graph’s ERC-8004 / Agent0 Subgraphs in Graph Explorer.

A Standard for Agents That Can't Be Trusted by Default

Autonomous AI agents are starting to act like economic participants. They call APIs, execute on-chain transactions, hire other agents, and settle payments, often across organizations that have never interacted before. The hard problem isn't capability anymore. It's trust: how does one agent know another is real, what it can do, and whether it has a track record worth paying for?

ERC-8004 is Ethereum's answer. Authored by Marco De Rossi (MetaMask), Davide Crapis (Ethereum Foundation), Jordan Ellis (Google), and Erik Reppel (Coinbase), the standard defines three lightweight on-chain registries that any agent can plug into:

• Identity Registry: An ERC-721-based handle that resolves to an agent's registration file (name, capabilities, endpoints, payment addresses).
• Reputation Registry: A standard interface for posting and fetching client feedback, tagged and scored.
• Validation Registry: Generic hooks for recording independent validator checks (TEE attestations, zk proofs, crypto-economic stakes).

The chain is the control plane. Heavy artifacts (like registration files, feedback bodies, and validation evidence) live off-chain on IPFS or HTTPS, referenced by URI. It's deliberately minimal so trust models can evolve without re-deploying contracts.

With ERC-8004 as the protocol, Agent0 is the SDK that makes it usable. Built by Marco De Rossi in collaboration with Consensys, MetaMask, and Agent0 Inc., Agent0 SDK enables developers to ship in TypeScript and Python, handle registration, capability advertisement (like MCP tools and A2A skills), x402 payment flows, and — critically — abstracts the data layer that makes agent discovery actually work at scale.

That data layer is The Graph.

Why Agent Discovery Needs Subgraphs, Not RPC Calls

Reading raw events from a blockchain is fine when you know exactly which contract, which block, and which agent ID you want. It falls apart the moment you ask the kinds of questions agents and their developers actually need answered:

• "Find me every active agent that supports MCP code generation, has TEE attestation, accepts x402 payments, and has an average score above 85."
• "Show me the last 50 feedback entries for agent 8453:1247, including the offchain text and any responses."
• "Across every chain we support, how many agents registered this week?"

Hitting an RPC endpoint for this means scanning thousands of blocks per chain, parsing event logs, fetching IPFS files, joining feedback to identities, and praying you don't hit a rate limit. Doing it in real time, for every agent and every other agent in the network, is a non-starter.

The Agent0 Subgraph turns the registries into a queryable index. Every Registered, MetadataSet, NewFeedback, FeedbackRevoked, ValidationRequest, and ValidationResponse event is captured as it happens. IPFS-hosted registration and feedback files are fetched and parsed via File Data Sources, so off-chain metadata (like agent names, MCP tools, A2A skills, trust models, x402 support) is queryable alongside on-chain data. Aggregations like average score, score distribution, and per-protocol totals are computed at index time.

The result: thousands of agents searchable in milliseconds, with rich filtering, no RPC limits, and always up-to-date as new blocks arrive.

What's Indexed

The Agent0 Subgraphs, which have already been queried millions of times, provide a unified GraphQL schema across all supported networks:

Identity: Each agent's on-chain ID, owner, operators, registration URI, creation and update timestamps, plus the parsed registration file: name, description, image, MCP/A2A endpoints, supported trust models, ENS, DID, agent wallet address, and x402 support.

Capabilities: MCP tools, prompts, and resources. A2A skills and tasks. OASF taxonomy tags for standardized discovery. Anything an agent advertises in its registration file is searchable.

Reputation: Every feedback entry with score (0–100), tags, client address, and a link to the off-chain feedback file (text, capability rated, skill, task context, proof of payment). Revocations and responses are tracked. Per-agent stats include total feedback, average score, score distribution buckets, and last activity.

Validation: Validation requests, responses, validator addresses, scores, tags, and lifecycle status (pending, completed, expired).

Protocol and global aggregates: Per-chain protocol entities and a global stats entity rolling up totals across every supported network.

Live on Five Mainnet Chains

The Agent0 Subgraph is deployed and indexing on:

• Base
• BNB Chain
• Ethereum
• Monad
• Polygon

A single GraphQL schema spans all five. Switching chains is a query parameter, not a code rewrite. As ERC-8004 expands to additional networks, new deployments slot into the same template-based architecture in under five minutes.

What This Unlocks for Builders

A few of the workflows the Subgraph makes trivial:

Agent marketplaces and discovery UIs: Render a directory of every active agent on a chain, filtered by capability, trust model, or reputation. Sort by score. Paginate through thousands of results without touching an RPC.

Agent-to-agent discovery at runtime: When one agent needs to hire another — say, a trading agent looking for a code-review agent that supports a specific MCP tool — it can query the Subgraph directly, score candidates by reputation, and pick a counterparty in a single round trip.

Reputation dashboards: Surface an agent's full feedback history, score distribution, validation record, and response activity. Build trust scores, leaderboards, or insurance pools on top.

Cross-chain analytics: Track adoption of ERC-8004 across networks. Compare agent counts, feedback volume, and active capabilities between Base, Ethereum, Monad, and the rest.

Agent CRMs and monitoring: Watch for new registrations, feedback events, or validation outcomes affecting agents you care about — no polling, no rate limits.

Try It Now

The fastest path:

1. Find an Agent0 Subgraph: search "agent0" on Graph Explorer and pick the network you want.
2. Get an API key from Subgraph Studio.
3. Query the gateway at https://gateway.thegraph.com/api/<API_KEY>/subgraphs/id/<SUBGRAPH_ID>.

Or use the Agent0 SDK, which wires up the right Subgraph endpoints by default. From the SDK you can register an agent, advertise its MCP and A2A capabilities, post feedback, and search for counterparties without writing GraphQL by hand.

A starter query to get you going:

query FindMCPAgents {
  agentRegistrationFiles(
    where: { mcpEndpoint_not: null, active: true }
    first: 25
  ) {
    agentId
    name
    description
    mcpEndpoint
    mcpTools
    supportedTrusts
  }
}

Why This Matters for The Graph

The agent economy is going to generate the most aggressive demand for structured blockchain data we've ever seen. Agents don't manually click through block explorers… they query, they decide, they act, and they do it thousands of times a minute. Every agent that uses ERC-8004 needs an index of every other agent. Every reputation lookup, every capability filter, every cross-chain discovery is a query.

Subgraphs were built for exactly this. Fast, composable, multi-chain, real-time, and credibly neutral. The Agent0 Subgraph is the first piece of dedicated agent infrastructure on The Graph — and the foundation for a much larger surface of agent-native data products coming over the next year.

If you're building on ERC-8004, you don't need to build an indexer. We already did.

Resources

• Agent0 SDK docs
• Supported networks
• Subgraphs on Graph Explorer
• ERC-8004 specification

About The Graph

The Graph is the leading indexing and query protocol powering the decentralized internet. Since launching in 2018, it has empowered tens of thousands of developers to effortlessly build Subgraphs and leverage Substreams across countless blockchains, including Ethereum, Solana, Arbitrum, Optimism, Base, Polygon, Celo, Soneium, and Avalanche. With powerful tools like Substreams and Token API, The Graph delivers high-performance, real-time access to onchain data. From low-latency indexing to rapid token data, it serves as the premier solution for building composable, data drive dapps.

Discover more about how The Graph is shaping the future of decentralized physical infrastructure networks (DePIN) and stay connected with the community. Follow The Graph on X, LinkedIn, Instagram, Facebook, Reddit, Farcaster  and Medium. Join the community on The Graph’s Telegram, join technical discussions on The Graph’s Discord.