Agent Zero — ERC-8004 Trust Filter

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the whole burden and does it well: it enumerates exactly which fields come back, which are redacted to null and surfaced in the `locked` map, the `platform_listed` special case, and the error behavior with an unlock pointer for unindexed ids. It also discloses payment mechanics (endpoint, x402 price, how-to-pay hint) and the read-only nature implied by a GET-based teaser.

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?

Well front-loaded and scannable with an Args block, an example, and a return-shape paragraph. It loses a point for redundancy: the paid endpoint URL, price, and unlock pointer are restated across three separate sentences, and the `paid_upgrade` block repeats what the 'Paid counterpart' paragraph already said.

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?

No output schema and no annotations means the description is the only source of truth, and it covers return shape, redaction policy, edge-case platform-listed agents, error responses, and the upgrade path. For a two-optional-param read tool, an agent has everything needed to call it correctly and interpret the result.

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 coverage is 0% and the schema has no enum, so the description must compensate, and it does: it lists the allowed chain values ("base", "ethereum"), restates both defaults including the meaning of 19353 as Agent Zero, and glosses `agent_id` as the numeric ERC-8004 id. It also states both params are optional and independently defaultable.

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?

States a specific resource and framing: a credit-score-style teaser of one ERC-8004 agent's trust profile, and it names the exact paid counterpart endpoint that delivers the full version. It stops short of differentiating itself from the sibling `get_agent_summary`, which sounds like it could overlap, so an agent can't fully rule out that alternative from the text alone.

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?

Gives concrete invocation guidance including the `{}` zero-arg form, both defaults, and a worked example, plus a clear framing of this as the free preview versus the paid full report. It never explicitly says when to prefer it over siblings like `get_agent_summary` or `get_network_teaser`, and there are no stated exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 that the response is booleans-only, that locked fields come back as null inside a `locked` map, that an `error` field appears when the agent is not indexed, and it flags two deprecated fields with explicit sunset dates (2026-11-07). That is well beyond what 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-loaded with the purpose, then a clean Args block, then returns, then the paid upsell. It is dense rather than padded, but the defaults are stated twice (in Args and again in the Example sentence), and the paid-counterpart paragraph is long relative to the free tool's behavior.

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?

There is no output schema, so the description must enumerate return fields — and it does, listing reachability, TLS validity, x402 support, the three payment booleans, MCP/OpenAPI counts, well-known presence, owner-named, and status_label_v2 values. Combined with the error-field and locked-map notes, an agent has everything needed to call it and interpret the result.

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 and it does fully: `chain` is documented as one of "base" or "ethereum" with default "base" (an enum constraint the schema lacks), and `agent_id` is described as the numeric ERC-8004 id defaulting to 19353 (Agent Zero). The worked example `{"chain": "base", "agent_id": 19353}` makes the call shape unambiguous.

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?

States a specific verb and resource — counts-only objective signals for one ERC-8004 agent — and immediately bounds scope with the explicit exclusion 'No owner identity string and no payment amounts — those are paid.' An agent can tell exactly what this returns versus the paid intel endpoint without any ambiguity.

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?

Gives a concrete usage directive ('Use this to vet a counterparty agent before transacting') and names the paid alternative with the condition that selects it (when you need trust_verdict, readiness_score, Sybil-adjusted reputation). It does not differentiate from the similarly named sibling agent_trust_teaser, which an agent could plausibly confuse with this tool, so it falls just short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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.

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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full burden of explaining behavior. It does so well: it discloses the ≤200-node cap, truncation, free-to-paid distinction, and the `unlock` block in every response. It stops short of stating read-only safety or response format details, but the core behavioral traits are visible.

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 organized into three tight sections: what the result is, how to use it, and the paid upgrade path. Every sentence adds useful information, and the key cap/truncation facts are front-loaded in the first lines.

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 parameterless read tool, the description is complete: it defines the returned nodes/edges, the cap, the relationship to the paid full graph, and the unlock mechanism. There is no output schema, so the prose adequately covers what an agent would need to decide to call it.

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 for the description to explain. Per the baseline rule, 0 params receives a 4; the description gives no parameter information, but none is needed.

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 opens with a specific resource ('on-chain agent-to-agent payment graph') and a concrete behavior: 'Returns connected agents (nodes) and the value flowing between them (edges), capped to a small connected sample (≤200 nodes).' This is unambiguous and clearly distinct from sibling tools like get_agent_summary or get_leaderboards, which cover different data. The 'Use it to see who pays whom' line reinforces intent.

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?

It explicitly tells agents when to use this tool: as a truncated preview to see who pays whom, and names the paid alternative `GET /v1/intel/graph` for when the full network is needed. The condition (needing every node and edge without a cap) is stated directly, so an agent can route to the right tool without guessing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does: it states the probe is unauthenticated and read-only with no payment signed, discloses the free-tier row cap, and notes the total counts so the caller can gauge how partial the slice is. It also explains that every response embeds an unlock/paid_upgrade block, which is exactly the kind of side effect annotations could not convey.

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 text is dense but well-structured and front-loaded: purpose first, then args, then returns, then source/paid-upgrade. A few clauses are repetitive (the free-tier cap is implied twice) and it is longer than strictly needed, but almost every sentence earns its place.

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, the description enumerates the return fields (agent_id, chain, endpoint_url, http_402_ok, network, asset, price_usd, payTo_present, sibling_agent_ids, probed_at) plus the totals, which is exactly what the agent needs to interpret results. It even names the provenance probe, though field_test_url is referenced but omitted from the row list — a trivial gap.

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 and it does: `chain` is documented as one of "base" or "ethereum" with omit-for-both semantics (the schema declares no enum), and `limit` is bounded to 1..10 with the free-tier cap and default of 10. This adds essential meaning the bare schema lacks.

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?

Names a concrete resource (a directory of ERC-8004 agents that passed an HTTP 402 x402 challenge) with the qualifying condition, so the agent knows exactly what surface it enumerates. The explicit 'OBSERVATION ONLY — not a score, ranking, or endorsement' line draws a boundary against ranking-style siblings like get_leaderboards. Verb+resource+scope is unambiguous.

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?

Gives clear calling context: all args optional, `{}` returns the top 10 across both chains, and the free tier caps at 10 rows. It also explains the paid counterpart and when enrichment is warranted, but it never routes the agent to a specific sibling by name. Strong context without explicit alternative selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.