Agent Zero — ERC-8004 Trust Filter
Server Details
Trust filter for ERC-8004: only ~3.8% of x402 endpoints hit 5+ payers/30d. Free MCP; x402 upgrade.
- Status
- Healthy
- Uptime
- 89.6% over 55 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
The four tools target distinct views: single-agent signals (get_agent_summary), market-wide counts (get_coverage_stats), ranked agent lists (get_leaderboards), and the payment graph (get_network_teaser). get_coverage_stats and get_leaderboards are both aggregate market views and could occasionally be confused, but descriptions clearly separate counts from rankings.
All four names follow a predictable get_<noun> snake_case pattern (get_agent_summary, get_coverage_stats, get_leaderboards, get_network_teaser). Only minor deviation is the plural 'leaderboards' versus singular nouns elsewhere, which does not impair readability.
Four tools is a reasonable, well-scoped set for a trust/intel server covering agent, market, ranking, and graph views. It leans slightly thin, but each tool earns its place and maps to a paid counterpart, so nothing feels redundant.
The server's stated purpose is vetting agents before transacting, yet the decision-driving values (trust_verdict, readiness_score, Sybil-adjusted reputation) are locked behind paid endpoints, so the free surface cannot complete the core task on its own. There is also no lookup/search-by-name or agent-listing tool, leaving notable gaps despite the paid workaround.
Available Tools
5 toolsget_agent_summaryAInspect
Objective, counts-only signals for one ERC-8004 agent.
Args (BOTH OPTIONAL — call with {} to see Agent Zero itself):
chain: one of "base", "ethereum". Default: "base".
agent_id: the numeric ERC-8004 agent id. Default: 19353 (Agent Zero, the agent serving this MCP endpoint).
Example: {} returns Agent Zero on base; {"chain": "base", "agent_id": 19353} is the explicit form.
Returns reachability, TLS validity, x402 support, payments-received (boolean only), MCP tool count, OpenAPI method count, well-known presence, owner-named (boolean), and a neutral status label (Live & monetized / Live, no payments / Stub or unreachable). No owner identity string and no payment amounts — those are paid. Returns an error field if the agent is not indexed. Use this to vet a counterparty agent before transacting.
Paid counterpart: GET /v1/intel/agent/{agent_id}?chain={chain} (x402, USDC on base-mainnet) unlocks trust_verdict (safe_to_transact / caution / avoid / insufficient_data), readiness_score, Sybil-adjusted reputation, and the commerce-backed breakdown — the decision-driving values this free response returns as null inside a locked map. Every response carries an unlock block with the exact paid endpoint, price, and payment discovery.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | base | |
| agent_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does so: it discloses what is deliberately excluded (no owner identity string, no payment amounts), the error behavior ('Returns an `error` field if the agent is not indexed'), the `locked` map of nulls, the `unlock` block contents, and the free-vs-paid boundary. This is well beyond what the (absent) structured fields provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the one-line purpose, then a labeled Args block, an Example, a Returns paragraph, and the paid counterpart. Length is justified by the absence of an output schema and parameter descriptions; no sentence is filler — even the 'no owner identity / no payment amounts' line earns its place by preventing wrong expectations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a free-scope read tool with no output schema and 0% schema coverage, the description supplies everything needed: parameter semantics, default behavior with no arguments, the return field set, the error case, and the paid upsell with exact endpoint and price discovery. Nothing an agent needs to call it correctly or interpret the response is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate entirely — and it does. It documents both params as optional, the chain enum values ('base', 'ethereum'), the default chain, the numeric meaning and default of agent_id (19353 / Agent Zero), and gives a concrete call example showing the empty-object form.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description's opening line states a precise verb+resource: objective, counts-only signals for one ERC-8004 agent. It enumerates the exact signals returned (reachability, TLS validity, x402 support, MCP tool count, etc.), so an agent knows exactly what it gets. It stops short of naming or contrasting the sibling tools (get_coverage_stats, get_leaderboards, get_network_teaser), which keeps it from a full 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states the decision context: 'Use this to vet a counterparty agent before transacting.' It also names the alternative and the condition that selects it — the paid counterpart endpoint is called out as the source of decision-driving values (trust_verdict, readiness_score) this free response returns as null. When-to-use and when-to-step-up are both covered.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_coverage_statsAInspect
Live coverage of the ERC-8004 agent economy across Base and Ethereum.
Returns counts only: how many agents are indexed, how many expose a live MCP server / OpenAPI / well-known card, total MCP tools and OpenAPI methods observed, contracts verified, EOAs and owners identified, plus a per-chain breakdown. No names, addresses, or handles. Use this to size the market and see where capability density is growing.
Paid counterpart: GET /v1/intel/market (x402, USDC on base-mainnet) returns the full capability market map — which capabilities are saturated vs open, per-capability agent lists, and momentum. Every response from this free tool carries an unlock block with the exact paid endpoint, price, and payment discovery.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since there are no annotations, the description must carry the full burden. It discloses that the tool is read-only (returns data) and details what is NOT included (e.g., no names/addresses), which is useful. It also mentions a unique behavior: every response includes an 'unlock' block with pricing info for a paid endpoint, which is helpful. It doesn't specify rate limits or error cases, but for a no-parameter read tool, this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise with two paragraphs. The first paragraph states the primary function and output format, which is good front-loading. The second adds the paid counterpart and unlock block, which is useful but slightly verbose. Each sentence contributes value, though the second paragraph could be tightened without losing key info. It is structured but not overly long.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and no annotations, the description is complete enough for an agent to call it correctly. It explains what to expect in the response (counts, per-chain breakdown) and the paid upgrade. There is no missing information that would prevent correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters and 100% schema coverage, the schema itself doesn't provide any parameter details. The description compensates by explaining the type of data returned (counts, breakdowns, per-chain) and the additional unlock block. This is valid because the tool takes no arguments, so the description effectively clarifies what the tool provides given no inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Live coverage of the ERC-8004 agent economy' with specific output details. It distinguishes itself by emphasizing it returns counts only, not actual names or addresses, which differentiates it from siblings like get_agent_summary. The verb 'get' and the resource 'coverage stats' are explicit and precise.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use this tool: to 'size the market' and see where capability density is growing. It also mentions a paid counterpart for more detailed data for those needing capability-level specifics. However, it does not explicitly state when NOT to use this tool or mention alternatives like get_agent_summary, though the definition implies the free/paid distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_leaderboardsAInspect
Top ERC-8004 agents by live capability, plus the most recently indexed.
Three ranked lists — top by live MCP tool count, top by OpenAPI method count, and most-recently indexed — each with agent_id, chain, public name, a shareable detail URL, and the relevant count. Names and counts only: no owner wallets, handles, or endpoint URLs. Use this to find the most capable / most active agents to integrate or watch.
Paid counterpart: GET /v1/intel/trending (x402, USDC on base-mainnet) returns trending intel — top earners, fastest-rising agents, and integration candidates ranked with the signals behind the ranking. Every response from this free tool carries an unlock block with the exact paid endpoint, price, and payment discovery.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden. It discloses exactly what fields are returned (agent_id, chain, public name, shareable URL, relevant count), what is excluded (owner wallets, handles, endpoint URLs), and that every response includes an 'unlock' block with paid endpoint/price/payment discovery. Minor omissions like pagination or rate limits are not critical for a no-parameter read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence adds value: it fronts the main purpose, then details the lists, then gives usage guidance and notes the paid alternative. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description fully explains what the response contains, what it omits, and the response's unlock block. For a zero-argument tool, this is sufficient for correct invocation and interpretation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, so there is nothing to clarify. Baseline for 0 params is 4; the description adds no unnecessary parameter commentary, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource ('leaderboards' of ERC-8004 agents) and a clear action (returns three ranked lists). It details exactly what the lists rank (live MCP tool count, OpenAPI method count, most-recently indexed), which distinguishes it from sibling tools like get_coverage_stats or get_agent_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use this to find the most capable / most active agents to integrate or watch.' It also names a paid alternative (GET /v1/intel/trending) and explains what that returns, giving the agent both a when-to-use and a when-not-to-use reference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
- Added
agent_trust_teaser
1 tool update
- Changed
get_agent_summary3 fields changed- added
Input schema / properties / agent_id / defaultAdded value: +19353 - added
Input schema / properties / chain / defaultAdded value: +"base" - removed
Input schema / requiredRemoved value: -[ - "chain", - "agent_id" -]
4 tool updates
- First observed
get_agent_summary - First observed
get_coverage_stats - First observed
get_leaderboards - First observed
get_network_teaser
Related MCP Connectors
x402-paid MCP data: trend feed + visibility audit. USDC/Base. No API key. No PII.
x402 MCP with exact and batched payments for recurring wallet, trading, market and web workflows.
Live x402 endpoint trust/diligence check before you pay it. $0.02/call via x402.
Payment-backed trust scores for AI agents on Base (ERC-8004). $0.01 per check via x402.
Related MCP Servers
- AlicenseAqualityBmaintenanceBefore an AI agent pays an x402 endpoint, checks whether it's safe to pay: liveness, scam/anomaly scan (payTo hijack, bait-and-switch, honeypot), and on-chain receiver verification. ~70% of x402 endpoints are dead or scams.3MIT
- AlicenseAqualityCmaintenanceMCP server for assessing counterparty risk in x402 payments using on-chain data, providing risk scores, decisions, and wallet spending policies to prevent fraud and unauthorized payments.1031 npm1MIT

tereno-mcpofficial
AlicenseNot gradedqualityBmaintenanceMCP server for verifying blockchain safety on Base via x402, with free pricing/receipt tools and paid per-call guard, contract, and metadata checks settled in USDC.34 npmMIT- AlicenseAqualityDmaintenanceAn MCP server that lets your AI coding agent (Claude Code, OpenClaw, Codex, Cursor, etc.) discover and pay on-chain agents registered on ERC-8004, using Coinbase's official x402 protocol. No smart account. No bundler. No relay. Just your EOA, an HTTPS request, and an automatic 402 → sign → retry flow.35MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.