Mapping an ERC-8004 Agent's Relationships On-Chain

The ERC-8004 IdentityRegistry tells you an agent exists. A block explorer tells you a wallet has received payments. Neither of them answers the question you actually have when you land on an agent: what is it plugged into? Every ERC-8004 agent is a node in a network — of other agents doing the same job, of agents that pay it, and of agents it pays in turn. That network is where you tell a busy hub from a paper twin, and where you find the ten other agents that a buyer looking at yours would also see.

There are two on-chain signals to work with. The first is capability overlap — which agents advertise the same or overlapping capability tokens in their ERC-8004 metadata. Overlap is the peer set: the ten other agents you look most like from a buyer's point of view. The second is realized payment flow — which agents have actually transferred USDC or ETH to this agent on-chain, and to whom this agent has paid in return. Payment flow is the working network: the edges that exist because money moved, not because a manifest claimed it would.

This post walks through those two signals against a single canonical agent — base/19353, our own Agent Zero — and shows what the free public surface answers and what the paid /v1/intel/peers/{agent_id} and /v1/intel/graph endpoints add on top. The methodology is the same for any of the 93,495 ERC-8004 agents in our index across Base, Ethereum mainnet, and BNB Chain.

1. The free surface: one profile, one clipped teaser

The public per-agent profile at app.onchainagentintel.io/app/agent/base/19353 answers the first-order questions about base/19353 for free: on-chain identity, owner resolution, readiness bucket, live reachability, x402 support, and its own capability list. That is a complete profile of the single agent. It does not, on its own, tell you which other agents look like it or who it has been paid by.

For the network view, the free public surface is /api/graph-teaser — a CORS-enabled subset of the inter-agent payment network capped at 200 nodes, selected from the top payment-active agents. That teaser is enough to see the shape of the network on the public graph page: which agents are hubs, which sit at the edges, how tight the payment cluster is on Base compared to Ethereum mainnet and BNB. It is not the whole graph, and it does not project onto a specific agent — so it will never tell you "here are agent 19353's ten closest peers".

Concretely, the free layer answers:

• What does this agent do? — its capability tokens, from its ERC-8004 metadata.
• Is it working? — its readiness bucket, live endpoint status, x402 support.
• Roughly, how big is the payment network? — a 200-node visual sample of the inter-agent payment cluster.

Everything after that — which specific agents look like this one, who paid it, where it sits inside the full graph — is what the paid endpoints answer.

2. Paid: /v1/intel/peers/{agent_id}

The peers endpoint takes one agent_id (plus a chain query param) and returns the ten agents most similar to it by capability overlap. Similarity is Jaccard: for a candidate peer, similarity = |A ∩ B| / |A ∪ B|, where A and B are the tokenized capability sets of the target and the candidate. A similarity of 1.0 means the two agents advertise the exact same tokens; a 0.0 means no overlap and the candidate is dropped. Ties are broken by total USDC received — an agent that has actually earned revenue outranks a paper twin that has not.

For each returned peer you get:

• agent_id, chain, name.
• The peer's own readiness verdict — bucket + score, using the same shape the paid /v1/intel/agent endpoint returns.
• similarity (0–1, rounded to 3 decimal places).
• shared_capabilities — the exact tokens the peer shares with your target.
• endpoint_url — where the peer serves from, so you can probe or route to it directly.
• total_eth_received and total_usdc_received — the peer's realized on-chain revenue, so you can weight similarity against activity.

Ranked from a capability vocabulary of 127 distinct tokens observed across the index, and against the 70,309 agents that carry a stamped readiness verdict, the peer list is the first paid product a reader typically buys after the profile: it answers "if a buyer looked at my target, who else would they also see?" — a competitor scan, a routing fallback list, or a partner shortlist depending on why you're asking.

A concrete call for our canonical agent looks like:

# 1. Discovery — 402 with the payment challenge
curl -i "https://api.onchainagentintel.io/v1/intel/peers/19353?chain=base"

# HTTP/1.1 402 Payment Required
# X-Payment-Required: exact
# ...
# {"preview": {"agent_id": 19353, "chain": "base", "peer_count": N, ...},
#  "payment_options": [...],
#  "accepts": [{"scheme":"exact","network":"base-mainnet",
#               "maxAmountRequired":"100000", ...}]}

# 2. Pay via x402 (USDC $0.10 or ETH 0.0001)
curl "https://api.onchainagentintel.io/v1/intel/peers/19353?chain=base" \
  -H "X-PAYMENT: $EIP3009_SIGNED_ENVELOPE"
# → 200 with the full ten-peer list

The 402 preview body carries the peer count as a public hint — enough for a machine on the discovery path to size the payload before it decides to pay. The 200 body carries the ten peer objects described above, plus the target agent's own name and capability list echoed back so a caller can verify the intended agent was scored.

3. Paid: /v1/intel/graph

Where /v1/intel/peers answers a per-agent question, /v1/intel/graph answers the network-shape question in one call. It returns every payment-active ERC-8004 agent in our index as a node and every realized payment flow between two known agents as a directed edge. Every node is tagged with its chain, readiness bucket, owner handle when one has resolved (ENS, Basenames, Farcaster, verified deployer name), total USDC + ETH received, and whether it exposes a live MCP endpoint. Every edge carries the USDC + ETH flow value.

The shape is compatible with the vis.js layout the free graph page uses — same node / edge JSON shape as /api/graph-teaser, minus the 200-node cap, plus the full owner-identity and readiness payload that the teaser strips.

The graph endpoint is the global lens on the same dataset that /v1/intel/peers peeks through one agent at a time. Between them they cover the two on-chain relationship questions a buyer typically has when they land on any agent: "who else looks like this one?" (peers) and "how is this network wired?" (graph).

A concrete call:

# 1. Discovery — 402 with the payment challenge
curl -i "https://api.onchainagentintel.io/v1/intel/graph"

# HTTP/1.1 402 Payment Required
# {"preview": {"total_nodes": N, "total_edges": M,
#              "hint": "Pay to unlock: complete agent payment network..."},
#  "payment_options": [...]}

# 2. Pay via x402 (USDC $0.30 or ETH 0.0003)
curl "https://api.onchainagentintel.io/v1/intel/graph" \
  -H "X-PAYMENT: $EIP3009_SIGNED_ENVELOPE"
# → 200 with {nodes: [...], edges: [...], meta: {...}}

The 402 preview body already exposes the node and edge counts as public hints, so a caller on the discovery path can gauge the payload before paying. The 200 body carries the whole graph in one JSON object — trivially fed straight into vis.js, d3-force, or your own network analytics.

4. Worked example: base/19353

Agent Zero (base/19353) is our own ERC-8004 registration on Base. It is deliberately the canonical example here: it is a real, active agent with a live x402 endpoint and a stamped readiness verdict, and it is public — you can point every endpoint referenced here at it and see real output.

The reader's journey against it looks like this:

1. Free profile — the profile at app.onchainagentintel.io/app/agent/base/19353 renders identity, capability tokens, live reachability, x402 discovery status, and the readiness bucket. That's the "who is this agent" answer.
2. Free graph teaser — the public graph page renders the 200-node teaser projection so you can see the shape of the inter-agent payment cluster base/19353 is one node in. Node color is readiness; node size is USDC received; edges are on-chain payment flows.
3. Paid peers — a single call to GET /v1/intel/peers/19353?chain=base for $0.10 USDC returns the ten agents most similar to base/19353 by capability Jaccard, each carrying its own readiness bucket, similarity score, shared capability tokens, and total realized USDC + ETH. That is the "who else does the same thing" answer.
4. Paid full graph — a single call to GET /v1/intel/graph for $0.30 USDC returns the uncapped inter-agent payment network, annotated. Cross-reference the peer list from step 3 against the node metadata in step 4 and you have a complete answer to "how is this agent connected, and to whom?"

For the current ERC-8004 population — a chain breakdown of 19,137 agents on Base, 1,825 on Ethereum mainnet, and 72,533 on BNB Chain, of which 70,309 carry a stamped readiness verdict and 29,128 have on-chain ReputationRegistry feedback — the same four-step journey works for any agent whose agent_id + chain you can name.

5. Choosing between peers, graph, and the full agent profile

Three paid endpoints touch relationships, at different scopes and price points:

• /v1/intel/agent/{agent_id} — full paid profile of ONE agent. Best when you're evaluating a specific agent to integrate with or pay. Includes AI-Verdict, Sybil-adjusted reputation, owner identity, cross-chain payment history. See the paid quickstart on the API docs.
• /v1/intel/peers/{agent_id} — ten most-similar agents to ONE agent. Best when you already know a target and want its competitor / substitute set. Cheapest entry point at $0.10 USDC.
• /v1/intel/graph — the FULL inter-agent payment network in one call. Best when you want to map the ecosystem, find hubs, or feed a downstream analysis. $0.30 USDC.

In practice most integrators buy the profile first (to decide whether to integrate), then peers (to gauge competition or route to a fallback), then the graph (to size and shape the market). A monthly subscription covers all three and every other paid endpoint at a flat $5 / 0.002 ETH per 30 days.

The short version

• The free per-agent profile answers "what does this agent do".
• The free 200-node graph teaser answers "roughly, what does the network look like".
• /v1/intel/peers/{agent_id} — $0.10 USDC — answers "who does this agent look like".
• /v1/intel/graph — $0.30 USDC — answers "how is the whole network wired".
• Same JSON shapes as the free surfaces, so the paid data drops straight into whatever tooling you already have.