APEX on Arc

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

With no annotations, the description carries the full burden. It clearly indicates this is a paid operation with a specific payment flow, something an agent must know before invoking. It also implies a read-only nature but doesn't explicitly state it; however, the payment requirement is a critical behavioral disclosure.

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 three sentences, front-loaded with the core purpose, then the cost and payment flow. It's efficient, but the payment flow explanation could be seen as slightly dense for a single sentence.

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 tool with one optional parameter and no output schema, the description covers the what, the when, and the how-to-pay. It lacks details on the output format, but since there's no output schema, this is a minor gap. The description is comprehensive for an agent to use it correctly.

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 schema has one parameter (payment) with 100% description coverage. The description adds significant context beyond the schema: it explains the payment parameter's role in the two-step flow, including the format (base64 payload) and how it completes the purchase. This enriches the schema's minimal description.

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 maps the agent economy on Arc by listing agents in the ERC-8004 registry, including owner, services, and x402 acceptance. It distinguishes itself from siblings like arc_agent_search and arc_agent_status by focusing on the registry-wide mapping, though it doesn't explicitly name a sibling.

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 explains the two-step payment flow: first call without payment to get terms, sign them, then call with payment. It also specifies the payment methods and cost, which is crucial for calling the tool correctly.

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?

No annotations are provided, so the description carries the full burden. It discloses the data returned (reputation entries, summary, uptime records) and the rate limit (200 calls/day), adding meaningful context. It does not explicitly state read-only nature, but it is clearly implied. It adds value beyond the schema by describing the output composition.

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 a single sentence that efficiently packs the core purpose, the included data, and the rate limit. It is front-loaded with the main function and appends constraints. While dense, there is no redundancy or wasted words.

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 thoroughly explains what is returned: reputation entries with specific fields, registry summary, and uptime records. It also provides rate limit information. For a one-parameter tool, this is complete and leaves no critical gap for an agent to call it correctly.

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 100% and the single parameter agentId is clearly described in the schema as the agent ID in Arc's ERC-8004 registry. The description does not add further parameter semantics, so it meets the baseline expected given high schema coverage.

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 explicitly states the tool retrieves reputation data for an Arc agent: every ERC-8004 entry (who gave it, value, tags, revocation status), the registry's summary, and weekly uptime records. It clearly differentiates from siblings like arc_agent_status by focusing on reputation and includes a distinct data scope.

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?

No explicit guidance on when to use this tool vs alternatives. It mentions free usage and a rate limit but does not state selection criteria relative to sibling tools such as arc_agent_status or arc_agent_search. The description implies a read-only data lookup but provides no contextual hints for choosing it.

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 behavioral burden and does a good job: it reveals the underlying registry, that it is updated hourly by APEX Watchtower, the exact return fields, the free tier with 200 calls/day, and what this tool is not (the full directory). It stops short of describing query matching behavior or result limits, but the disclosed information is substantial.

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?

Two sentences contain the core action, search scope, return fields, rate limit, and a pointer to the sibling tool. Every clause earns its place, and the most important purpose information is front-loaded.

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 simple two-parameter search tool with no output schema, the description covers the essential fields returned and the data source. It also gives a helpful alternative for richer data. It could mention result ordering, pagination, or no-result behavior, but these are minor gaps given the tool's simplicity.

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 100%, so the schema already fully documents query and payableOnly. The description adds context by mentioning search is by name/endpoint and that results include whether the agent can be paid on Arc, which aligns with the payableOnly parameter. However, it does not materially extend the parameter meaning beyond the schema.

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 verb and resource: 'Find an agent on Arc by what it is called or where it answers', then defines the search scope as Arc's ERC-8004 registry. It also differentiates itself from the sibling arc_agent_market by clarifying that this tool returns a subset of fields rather than the full directory with owners and every service.

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 makes the use case clear: searching across agents by name or endpoint. It points users to arc_agent_market when they need the full directory, owners, and every service. It does not give explicit exclusions for other related siblings like arc_agent_status or arc_agent_reputation, but the primary alternative is clearly named.

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?

No annotations are provided, so the description carries the full burden. It discloses the mechanism (calls every endpoint hourly), the uptime calculation nuance (never counting unmeasured hours as down), the paid/free distinction, and the output fields. It doesn't mention side effects or auth, but as a status check it's implicitly read-only. The disclosure is strong but lacks explicit error-handling details.

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 verbose and somewhat rambling, starting with a rhetorical question and then covering the watchtower mechanism, output details, usage guidance, and pricing in a single block. It's informative but could be structured more clearly with sections or bullet points. It earns a 3 because it's not overly terse but could be better organized.

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 there is no output schema, the description must explain the return value, and it does: it lists status categories, uptime, response time, payment info, and fixes. It also covers both invocation modes and mentions the paid endpoint for full history. However, it doesn't specify what happens if an agentId is invalid or the response format details, but for a status tool this is reasonably complete.

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 100%, so the baseline is 3. The description adds significant value beyond the schema by explaining the effect of including vs. omitting agentId (specific status vs. whole-registry counts) and the exact meaning of the parameter. This goes beyond a simple description of the field.

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 it checks whether an Arc agent actually answers, providing status, uptime, response time, payment info, and fixes. It distinguishes between the with-agentId and without-agentId modes, and none of the sibling tools address agent health, so it's uniquely identifiable.

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 explicitly says 'Call it before you pay or hire an agent,' providing a clear use case. It also explains the two invocation modes (with and without agentId) and mentions the paid endpoint for full history. However, it doesn't explicitly state when not to use it or name alternatives, though no direct sibling competitors exist.

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?

The description discloses that quotes are live, measured per source chain, refreshed every 10 minutes, and includes the X1 bridge minimum of 11 USDC. It also notes a CCTP mention. With no annotations provided, the description carries the burden and does a good job of setting expectations about data freshness and constraints, though it doesn't detail the exact output format or failure modes.

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 a single, information-dense sentence that front-loads the core purpose (USDC onto Arc) and then adds specifics. It's slightly long but every clause adds value: source chains, LI.FI, what's measured, refresh rate, X1 minimum, and CCTP note. The usage guidance at the end is a bit tacked on but not redundant.

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 zero-parameter tool with no output schema, the description covers the key context: what it does, how it works (LI.FI), what data it provides (cost, time, what arrives), freshness (10 minutes), and a usage scenario. It doesn't explain how to interpret the quote or what 'claim at the faucet' entails, but those are likely covered by sibling tools (arc_faucet_claim).

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 zero parameters, so the description doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description adds context about what the tool measures and returns, which is sufficient.

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: it provides live USDC bridge quotes to Arc (eip155:5042) from multiple source chains via LI.FI, including cost, time, and what arrives. It also mentions the X1 path and CCTP note, distinguishing it from generic bridge tools like bridge_assets or get_onto_x1.

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 explicitly says 'Use it to bring an agent or a person to Arc from wherever they are, then claim at the faucet,' giving clear context for when to use it. It doesn't explicitly state when not to use it or name alternatives, but the sibling list includes bridge_assets and get_onto_x1, and the description's specificity about Arc and USDC implies the alternative scenarios.

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 full burden but adds significant behavioral context: the free-during-development aspect, the x402 payment flow with specific assets and chains, and the need to call twice (first for terms, then with payment). It doesn't cover potential rate limits, data freshness, or exactly what the transactions array includes, but it discloses the payment mechanics and analysis scope.

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 front-loaded with the core question and key details, then transitions to payment logistics. It's fairly dense but not overly verbose. Some sentences are long, but every part contributes useful information about what the tool does and how to invoke it.

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 no output schema and no annotations, the description does a good job covering what the tool returns (creator's buy, funded wallets buying early, transactions) and the payment process. It lacks explicit guidance on when to use it versus similar tools and doesn't detail data sources or limitations, but it's largely complete for an agent to understand and call the tool.

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 100% for the single 'payment' parameter, which is well-described in the schema. The description adds the two-step payment flow (call without payment for terms, then with signed payment) and mentions passing a token or pool (though that's not in the schema, it's likely implicit in the tool's operation). Baseline 3 is appropriate when the schema already documents the parameter.

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 names a specific analysis verb ('bundled') and details exactly what it returns: creator's buy share of supply, funded wallets among first 60 swaps of first two minutes, and transactions. It distinguishes itself from siblings like arc_contract_check or arc_fresh_launches by focusing on launch bundling detection, though it doesn't explicitly contrast with them.

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?

Usage is implied by the description's focus on 'Arc launch' and the instruction 'Pass token or pool', which suggests it's for checking if a specific launch was bundled. However, there's no explicit when-to-use vs. alternatives, no when-not-to-use, and no mention of prerequisites beyond the payment process.

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 burden, and it does well: it discloses the data source (Circle's x402 catalogue), freshness (refreshed daily), ordering (cheapest first), and that it includes 'our own products with their prices for comparison.' It also states it is free. It does not mention pagination or rate limits, but the schema's limit parameter covers pagination.

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?

Three sentences, front-loaded with the core question, then the resource, ordering, fields, and use case. Every sentence earns its place; the final 'Free.' is a useful behavioral note, not filler.

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 search tool with 4 optional params and no output schema, the description is nearly complete: it names the catalogue, the ordering, the fields returned, and the use case. It does not describe the output shape, but with no output schema and a simple search result, the description's field list (host, path, category, settlement) gives the agent enough to know what to expect.

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 100%, so the baseline is 3. The description adds context for query ('keywords') and maxPrice ('optional price cap in USD') but does not add meaning beyond the schema for limit or network. The description's mention of 'cheapest first' and 'by keyword' reinforces query semantics but does not substantially exceed the schema.

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 concrete question ('Who sells this on Arc, and for how much?') and states the resource (Circle's x402 catalogue), the action (search by keyword, cheapest first), and the returned fields (host, path, category, settlement). It also distinguishes itself from the broader catalog_browse/catalog_product siblings by specifying it searches Circle's own x402 catalogue.

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 explicitly tells the agent when to use it: 'Use it to price a service before you build or buy it.' It also frames the catalogue as what Circle CLI agents buy from, refreshed daily, which implies it is the authoritative pricing source. It does not name alternatives, but the use case is so specific that an agent can route correctly.

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?

No annotations are provided, so the description carries the full burden. It discloses the payment flow (two-step: terms then payment), the cost, and the fact that passing `payment` completes the purchase inside the tool call. It doesn't detail what happens after payment or whether the call is idempotent, but the two-step flow is clearly explained.

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 compact and information-dense. Every sentence earns its place: what the tool measures, the cost, the two-step usage pattern, and the parameter semantics. It front-loads the core purpose before explaining the payment flow.

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 tool with one optional parameter and no output schema, the description covers the essential context: purpose, cost, supported assets/networks, and the two-step payment flow. It doesn't describe the output format, but given the tool's simple interface and the absence of an output schema, this is a minor 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?

The schema has 100% coverage for the single `payment` parameter, describing it as a signed x402 payment (base64 payload for PAYMENT-SIGNATURE). The description adds context about when to pass it (second call after signing terms) and that it completes the purchase, which goes beyond the schema's basic type description.

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: measuring the real cost of bringing USDC into Arc via Circle CCTP, with specific details about what is measured (arrivals, amount credited, fee taken, observed fees by size). It distinguishes itself from sibling tools like arc_bridges, arc_fee_flow, and arc_stablecoins by focusing on CCTP cost measurement from arrivals.

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 explicit usage guidance: call once without `payment` to get the terms, sign them with your own wallet, then call again with `payment`. It also states the cost ($0.004 per call over x402) and the supported networks (USDC on Arc, Base or Solana, or XNT on X1), which helps the agent decide when to use this tool.

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 provided, the description carries the full burden of behavioral disclosure. It mentions 'Read live from the chain' (implies read-only) and discloses the tool is free with a 200-calls-per-day limit. It also enumerates exactly what it checks, giving the agent a clear picture of the tool's behavior. It doesn't describe the return format (since no output schema exists), but it gives enough context for an agent to understand side effects and constraints.

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 a single, dense sentence that front-loads the use-case and enumerates checks. Every clause adds value: the trigger, the list of checks, the live-chain read, and the rate limit. No wasted words, well-structured for scanning.

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 tool with reasonable complexity (proxy, owner, token checks) and no output schema, the description gives enough for an agent to decide when to call it. It states the tool is Arc-specific, what it inspects, and its limits. The main gap is the absence of return-format details, but since no output schema exists, an agent can infer the output from the listed checks. It's sufficiently complete for selection and invocation.

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 schema already describes the 'address' parameter as '0x contract address on Arc' with 100% coverage. The tool description refers to 'a contract on Arc' but adds no additional syntax, format, or constraints beyond what the schema provides. Since schema coverage is complete, the baseline of 3 is appropriate—the description doesn't meaningfully enrich the parameter semantics.

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 explicitly states the tool's purpose: verifying that an address is a real contract, checking for proxy upgradeability (EIP-1967 implementation, admin, beacon slots), identifying the owner, and determining the token it claims to be. This is a specific verb-resource combo that clearly distinguishes it from siblings like arc_impostors or arc_exit_check.

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 opens with 'Before you approve, pay or trust a contract on Arc', which gives a clear contextual trigger for when to use the tool. It doesn't explicitly name alternative tools or state when NOT to use it, but the context is sufficient for an agent to infer appropriate use cases. A slight improvement would be naming specific alternatives, but it's already clear.

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 provided, the description carries full responsibility for behavioral disclosure. It transparently states the $0.004 per-call cost, the two-step payment process (terms first, then signed payment), and the data provenance guarantee ('Facts from the chain, never a label'). It omits rate limits or explicit read-only status, but the key behaviors are well covered.

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 front-loaded with the purpose question, followed by a compact list of metrics, then cost and payment steps. Every sentence contributes value—purpose, outputs, provenance, pricing, and invocation flow—with no filler. The metric list makes it slightly longer than strictly necessary, but each item sharpens the tool's scope.

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 no output schema, the description provides a solid overview of the return content (trading metrics and flags) and fully explains the required input and payment workflow. It doesn't specify the exact response structure or define 'flags', but the description gives enough for an agent to understand what to expect and how to execute the two-step call.

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 100%, so the baseline is 3. The description adds meaningful workflow context beyond the schema: it explains that calling without `payment` returns terms and that passing the signed `payment` completes the purchase. It also ties the `address` parameter to the trading-profile purpose, enhancing the schema's dry field description.

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 question—'Who is this Arc address as a trader?'—and then enumerates concrete outputs: first-buyer frequency, entry speed, USDC in/out, stuck positions, and flags. This is a clear, specific purpose that distinguishes it from generic wallet or reputation tools, even without naming siblings.

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 implies the use case (profiling a single Arc address's trading behavior) and gives detailed invocation steps for the x402 payment flow: call without payment for terms, sign, call again with payment. However, it never explicitly contrasts with sibling tools or states when not to use this tool, leaving alternatives unaddressed.

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 of behavioral disclosure. It transparently reveals the paid nature, the two-step payment flow, and the data returned (creators, launches, swap fees). However, it does not explicitly state whether the tool is read-only or has any side effects beyond payment. Given the context of a data-retrieval tool, this is a minor gap but the description is still highly transparent.

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 compact and front-loaded with the core purpose before diving into payment mechanics. It uses three sentences to convey purpose, cost, and usage steps without redundancy. The structure is efficient, though the payment details are dense and could potentially be broken out, but it remains appropriately sized for the complexity.

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 no output schema and one parameter, the description covers the essential aspects: what data is returned (creators, launches, fees), the payment flow, and the cost. It does not detail the exact output format, but the nature of the data is described. For a paid tool with a two-step process, the description is sufficiently complete for an agent to call it correctly, though a note on expected response structure would enhance 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 single parameter `payment` is well-documented in the schema ('a signed x402 payment (the base64 payload you would put in PAYMENT-SIGNATURE)'). The description adds crucial context on when to pass it ('Call once without `payment` for the terms... call again with `payment`'), which goes beyond the schema's static definition. This helps the agent understand the temporal dependency, making it more than a simple parameter description.

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 function: 'Who launched what on Arc and whether any of it ever traded: every repeat creator with their launches and the swap fees those launches earned.' This specific verb+resource distinguishes it from siblings like arc_fresh_launches (which likely focuses on fresh launches) and arc_agent_market (agents rather than creators). The purpose is unambiguous and not a tautology.

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 explicit usage instructions: 'Call once without `payment` for the terms, sign them with your own wallet, call again with `payment`.' It also specifies the cost and payment methods ($0.004 per call over x402 on USDC/XNT). This is a clear when-to-use and how-to-use guide, and it differentiates the two-step payment process from typical one-shot calls.

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 burden. It discloses the measurement basis (EIP-3009 authorization spend), the scope (on-chain, Arc USDC), and the inclusion of Circle's facilitators. It also notes the tool is 'Free', which is a behavioral/access trait. It does not mention pagination or rate limits, but the single optional limit parameter covers the main behavioral control.

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 a single dense sentence that front-loads the core purpose and then lists the output dimensions. Every clause adds information: measurement basis, scope, output fields, flow shape, and the Circle facilitator addition. No filler or repetition.

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 read-only analytics tool with one optional parameter and no output schema, the description is nearly complete. It tells the agent what data it returns and the measurement basis. The only missing context is what 'flow shape' means precisely (direct, circular, concentrated, self or contract are listed but not defined), and there is no explicit statement about the return format. These are minor gaps given the tool's simplicity.

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 100% for the single parameter, so the schema already documents 'limit'. The description does not add detail about the limit's effect beyond what the schema says (default 15, max 60). Baseline 3 is appropriate because the schema carries the parameter meaning fully.

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 verb ('settles'), a resource ('x402 payments on Arc'), and a precise measurement basis ('every relayer that spent an EIP-3009 authorization on Arc USDC'). It also enumerates the exact outputs (settlements, payers, payees, volume, flow shape) and names the two facilitator categories. This clearly distinguishes it from siblings like arc_x402_stats or x402_inspect.

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 implies when to use it: when you need relayer-level settlement detail on Arc, including Circle's facilitators. It does not explicitly state when not to use it or name alternatives, but the specificity of 'measured on the chain' and the relayer focus provides clear context. A small gap: no explicit exclusion of other x402 tools.

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 provided, the description carries the full burden and handles it very well: it discloses that the operator pays gas, that a contract enforces cooldown/daily limits, that there is no withdraw function, the UTC open windows, and the 8-hour per-connection limit. It even states what a refusal means and names the response fields.

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 mostly earns its length because it packs a two-step protocol, timing windows, and response fields into a compact paragraph. It is front-loaded with the core action, though a phrase like 'Same claim for everyone' adds only modest value.

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?

The tool has no output schema, so the description's mention of nextClaimAt and claimNumber fills that gap. Accounting for the two-step signature flow, cooldown behavior, and response contents, nothing needed to use the tool correctly is left unexplained.

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 100%, so the baseline is 3, and the description reinforces the schema's address and signature meanings. It adds useful detail beyond the schema by specifying that the signature must be personal_sign from the address's key and that the first call intentionally omits signature to receive the challenge.

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 action ('Claim real USDC and APEX on Arc') and identifies the resource and target address, so the tool's role is unmistakable. It also includes a two-step protocol that sets it apart from status/metrics siblings like arc_faucet_status and faucet_metrics.

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 gives explicit step-by-step invocation guidance: call with only {address} first, sign the challenge with EIP-191, then call with {address, signature}. It explains timing and cooldown constraints, but it does not explicitly name alternative tools or say when not to use this one.

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 provided, the description fully carries the behavioral burden and does so excellently: it discloses live reads from the contract, honest error behavior (failed reported as failed, never zero), cost ('Free'), and the three-part daily release schedule. This is highly transparent for a status 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?

Every sentence earns its place. The description front-loads the core status payload, then adds crucial behavioral details and the chain identifier without any filler. Dense but well organized.

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 zero parameters, no annotations, and no output schema, the description is complete: it lists every returned datum, explains the timing semantics, clarifies live vs cached reads, and specifies error and cost behavior. An agent has everything needed to call and interpret the tool correctly.

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 the baseline is 4. The description adds relevant output-context semantics even though no parameters exist to document.

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 (APEX faucet on Arc) and explicitly enumerates the data points returned: pot, claim amounts, claims left today and right now, release timing, and cooldown. It clearly identifies this as a status read, distinguishing it from the claiming sibling arc_faucet_claim without naming it.

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?

Clear context is provided about what information is available and how to interpret nextReleaseAt with specific UTC release times. However, it does not explicitly state when to prefer this tool over alternatives like arc_faucet_claim or faucet_metrics, so it earns a 4 rather than 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?

With no annotations provided, the description carries the full behavioral burden. It discloses the two-phase x402 payment flow, pricing, supported currencies, the fact that changes are measured against a previous scan, and that the purchase completes inside the tool call. This is unusually transparent for a paid 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 three dense sentences with no filler. The data result is front-loaded before payment instructions, and each clause contributes distinct information: result contents, fee source, pricing, and workflow.

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 one optional parameter and no output schema, the description is complete: it states what data will be returned and exactly how to complete the payment flow. An agent has everything needed to call the tool correctly without inferring missing details.

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 schema already describes `payment` clearly with 100% coverage, so the baseline is 3. The description adds value by explaining the exact call sequence—get terms without payment, sign with your own wallet, then resubmit with payment—making the parameter's role actionable beyond the schema.

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 defines the tool as a view over Arc launchpad fee vaults, listing current USDC vaults, their creators, tokens, and change since the previous scan. It lacks an explicit verb like 'list' or 'show,' but the colon-style definition and concrete return fields make the purpose clear and distinguishable from siblings.

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 gives an explicit usage workflow: call once without `payment` to receive terms, sign them, then call again with `payment`. It also states the per-call cost and accepted currencies. It does not name alternatives or exclude other use cases, but the context is sufficient for an agent to know when to invoke it.

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 well: it discloses pricing ($0.003/call), the accepted x402 payment rails (USDC on Arc/Base/Solana, XNT on X1), the payment handshake, and the provenance of the verdicts (first 60 swaps of the first two minutes, earliest 12 buyers' funders). This is exactly the behavioral context an agent needs before paying to call.

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 and the value proposition, then the payment mechanics. Dense but nearly every clause carries a distinct fact; the parenthetical on swap/buyer sampling is long but justifies the trust claim.

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 one-parameter, no-output-schema, paid tool, the description covers everything needed to call it correctly: cost, accepted currencies, the sign-then-resubmit flow, and what the returned verdicts mean and where their raw evidence lives.

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?

Only one parameter, and schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by explaining the semantics of omitting `payment` (returns terms) versus supplying it (purchase completes in-call), which is the key operational distinction the schema alone does not convey.

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 specific resource (real-time Arc launches / new pools) and states precisely what each result carries: a sell verdict from a real round trip and a bundle verdict. It also implicitly differentiates itself from arc_bundle_check by naming it as the place the raw evidence lives, so the agent can tell the summary tool from the evidence tool.

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 explicit invocation instructions, including the two-step handshake (call once without `payment` for terms, sign with your own wallet, call again with `payment`). It does not, however, state when to prefer this over siblings such as arc_pools or arc_exit_check, nor any 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 burden. It discloses the two-phase workflow (terms then payment), the cost, and that payment completes the purchase within the same tool call. However, it doesn't specify what the response looks like when terms are returned or what happens if payment fails, which is a minor gap given the paid nature.

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 compact and front-loads the core value (real costs) before procedural details. Every sentence earns its place; no fluff.

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 tool with one optional parameter and no output schema, the description covers the workflow and cost adequately. The only minor omission is what the returned data looks like (e.g., a table of percentiles), but the high-level outcome is clear. It's sufficient for an agent to proceed correctly.

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 100% for the single `payment` parameter, so the schema already describes it as a signed x402 payment. The description adds context on how to use it (the two-call workflow) but not much beyond. Baseline 3 is appropriate given high schema coverage.

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 reports actual Arc transaction costs with percentiles and sample sizes, distinguishing it from quoting docs. It also mentions the specific cost ($0.004 per call) and the payment workflow, making its purpose unmistakable.

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 provides explicit instructions: call once without `payment` to get the terms, sign them, then call again with `payment`. It implies this is the tool for Arc gas costs, standing apart from siblings like arc_cctp_cost or arc_x402_stats, and tells the agent exactly when to use it.

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 burden. It discloses the $0.025 per-call cost, accepted tokens, and the two-step payment process. It doesn't describe the response format or potential side effects, but for a data-listing tool this is acceptable.

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 two sentences, front-loaded with the core purpose, followed by cost and payment instructions. No redundant information; every sentence adds value.

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?

The description covers the tool's purpose, cost, and payment flow, which are the critical aspects for correct usage. It doesn't specify the exact output structure, but since there's no output schema and it's a simple data listing, the information provided is adequate.

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 100% for the single 'payment' parameter, and the schema already explains its format and purpose. The description adds context about the sequential usage (first call without, second with), which enriches the parameter semantics.

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 provides a list of dead Arc pools with state and lifetime volume, enabling users to know where selling is impossible. It is distinguishable from siblings like arc_pools by name and content, though it doesn't explicitly compare to alternatives.

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 explains when to use the tool (to know dead pools) and provides a clear payment flow: first call without payment for terms, then sign and call with payment. It doesn't explicitly contrast with alternative tools, but the context is sufficient for most use cases.

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 provided, the description carries full disclosure burden and does so thoroughly: it explains the swap of half the USDC, minting of a full-range Uniswap v4 position to the caller, refund of leftovers, non-custodial nature, removal path, mode-dependent behavior, and the price-check condition. This goes well beyond a minimal description.

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 efficiently structured: the deposit action leads, followed by removal, then the read-mode distinction and the price warning. Every sentence earns its place, and there is no filler or restatement of the tool name.

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 single optional parameter tool with no annotations and no output schema, the description provides enough context to call it correctly: what it does, how to use it, what changes with the parameter, and when not to act. Nothing essential 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?

Although the schema covers the optional address parameter, the description adds meaningful semantics by explaining what happens with and without it: with an address it returns positions/deposit/value; without it returns the contract, ABI, steps, and price comparison. This gives an agent actionable parameter behavior beyond the schema.

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 action, resource, and scope: putting USDC to work in the APEX/USDC pool on Arc via the ArcGrow contract. It is clearly distinguishable from sibling tools like arc_pools or arc_market because it names the exact contract method, the pool, and the non-custodial mechanism.

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 gives clear operational guidance: deposit with USDC as native value, remove liquidity via the PositionManager methods, use an address to read positions, and avoid depositing when the price divergence exceeds 10%. It does not explicitly name sibling alternatives or exclusions, but the usage context is unambiguous.

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?

No annotations are provided, so the description carries the burden. It discloses that the call is read-only ('no chain call'), costs $0.003, and requires a two-step payment process (call once for terms, sign, call again with payment). This is significant behavioral transparency, though it doesn't mention error handling or rate limits.

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 front-loaded with the core purpose, then explains the payment mechanism. It's concise but includes necessary details like pricing and the two-step call process. No redundant fluff.

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's complexity (payment flow, two-step invocation), the description covers the essential usage. It explains what the tool does, how to pay, and clarifies it's a capability check. It lacks output format details, but no output schema exists, so the agent may need to infer from context. Overall, adequate.

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 100%, so both parameters are already described. The description adds the payment flow context but does not add parameter-specific semantics beyond what the schema provides. Baseline of 3 is appropriate given high schema coverage.

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 verb and resource: it reads permission bits from a Uniswap v4 hook address on Arc, clarifying it determines allowed actions (runs on swaps, rewrites amounts). It distinguishes itself by noting it's a capability check, not a verdict, which differentiates from similar arc_* tools like arc_verdict.

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 provides context on when to use it (checking hook permissions without a chain call) and explains the payment flow, but does not explicitly name alternatives or conditions when not to use it. Siblings like arc_contract_check might overlap, but no explicit routing is given.

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 a good job: it discloses the $0.004 cost, the two-call x402 payment flow, the need to sign terms with your own wallet, and the important semantic rule that identity is the contract, not the symbol. It does not explicitly state read-only behavior or data freshness, but the query nature is clear.

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 compact and front-loaded: the first sentence states the core output and identity rule, and the second sentence covers the payment mechanics. Every sentence earns its place with no fluff or repetition of schema details.

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 single-optional-parameter paid query with no output schema, the description covers the essential context: what is returned, the identity caveat, cost, currencies, and the payment handshake. It stops short of describing exact return formatting or pagination, but those are minor gaps for this tool's simplicity.

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 100% and the schema already describes payment as a signed x402 payload. The description adds meaningful context beyond the schema by explaining the required two-step flow: call without payment to receive terms, sign them, then call again with payment. This clarifies when the optional parameter should be present.

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 identifies the resource: every token symbol on Arc shared by more than one contract, including share counts and the canonical verified address. It is specific and not a tautology, but it does not explicitly differentiate itself from the closely named sibling tool impostor_check.

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 implies when to use it (when you need a list of symbols worn by multiple contracts) and gives concrete invocation steps for the payment flow. However, it does not explicitly state when not to use it or mention alternatives such as impostor_check, leaving the agent to infer the boundary.

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 must disclose behavior fully. It covers cost ($0.99), payment chain (USDC on Arc/Base), minting and delivery to signing wallet, return of agentId and both transactions, and the no-charge guarantee. This is strong transparency for a purchase tool, though it omits failure modes and reversibility.

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 a single, dense paragraph that front-loads the purpose and process. It is efficient with no wasted words, though it packs a lot of information that might benefit from splitting into bullet points.

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?

The description explains the two-step process, the return value (agentId and both transactions), and the no-charge policy. However, it does not cover error handling, what happens if payment is invalid, or detailed parameter guidance. For a tool with 5 parameters and no output schema, this is a moderate 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 only 20% (only 'payment' has a description). The description explains 'payment' semantics and the two-step flow, but does not provide guidance for the required 'name' and 'description' parameters or optional 'image' and 'services'. Given low coverage, the description should compensate but does not.

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 action (buy ERC-8004 identity) with a specific method (signature alone) and distinguishes it from sibling tools like arc_passport_draft and arc_passport_status by focusing on the purchase and completion flow. It leaves no ambiguity about the tool's primary function.

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?

Provides explicit step-by-step usage: call without 'payment' to get terms, sign them, call again with 'payment'. Also notes that refused inputs are never charged, which helps the agent decide when to invoke. Does not explicitly compare to alternatives, but the usage is clear.

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 disclosure burden and does well: it explains the legacy-flow ordering dependency, the deadline, and the split from the buy path. It omits what happens on success/failure, whether the call is idempotent, and any gas/permission notes, so it falls short of full behavioral coverage.

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?

Two sentences, front-loaded with the primary action and precondition, and the alternative path is a trailing qualifier rather than clutter. Every clause 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?

For a two-parameter completion call with no output schema and no annotations, the description supplies the flow context, deadline, and routing alternative an agent needs. It stops short of describing return values or error/deadline behavior, which the absence of an output schema leaves unaddressed.

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 100% and both parameters are documented in the schema itself, including that tx is the register() hash and slug is the 12-character draft id. The description restates 'draft slug' and 'transaction hash' but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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 (finish) and resource (passport started in the old flow) and names the sibling it is not (arc_passport_buy for new passports). An agent can distinguish it from arc_passport_draft and arc_passport_buy without opening any schema.

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 an explicit precondition ('after the register() transaction from the old flow'), a cutoff date ('before 1 Oct 2026'), and a named alternative with a price for the other path ('New passports are bought with arc_passport_buy ($0.99)'). When-to-use and when-not-to-use are both covered.

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?

No annotations are provided, so the description carries the full burden. It discloses the critical behavioral fact that the tool is retired and returns a static response rather than performing any passport creation. It does not explain why the schema still requires name and description, which is a meaningful gap for a schema that looks like a creation 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?

A single dense sentence with the retirement notice front-loaded. Every clause earns its place (status, cost, human path, agent path, current behavior), though the sentence is packed.

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?

It explains the tool's dead-end behavior and points to alternatives, which is enough to avoid misuse. However, it leaves unexplained why a retired tool still declares two required parameters, and there is no output schema to clarify what the canned answer looks like.

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 100%, with every parameter documented inline, so the baseline is 3. The description adds no parameter meaning and does not reconcile the mismatch between the required name/description fields and the tool's stated no-op behavior.

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 the tool's status (RETIRED) and its current operation precisely: it returns a single canned answer about Arc Agent Passport pricing. This clearly distinguishes it from arc_passport_buy, which the description names as the actual purchase path.

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 routes the agent: humans pay at the given URL, agents use arc_passport_buy, and this tool only returns that answer. An agent knows exactly when to use it (never, for purchasing) and which sibling to call instead.

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 must carry the behavioral burden. 'Look up' implies a read operation and 'Free' discloses cost behavior, which is useful. But it does not explicitly state that no mutation occurs, nor does it mention auth requirements, rate limits, or failure behavior.

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?

One compact sentence that front-loads the action and resource, uses a colon to introduce the output fields, and ends with the cost qualifier 'Free'. Every clause earns its place; there is no redundancy or filler.

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 single-parameter lookup with no output schema, the description adequately captures the accepted input, the returned data categories, and cost. Minor gaps remain around error responses and invalid-ref behavior, but they are not critical for an agent to select and invoke the tool.

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 input schema already fully documents the single parameter, including the agentId-as-number and 12-character slug alternatives. The description only restates 'by agentId or draft slug' without adding new format or usage nuance, so it provides no meaningful semantic value beyond the schema.

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 action ('Look up an Arc Agent Passport'), the resource, and the accepted reference formats. The colon-separated list of returned fields makes the tool's scope concrete and distinguishes it from transaction-oriented siblings like arc_passport_buy or arc_passport_draft.

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 clearly implies the use case: retrieve passport status by ref. However, it does not explicitly say when to prefer this over alternatives such as arc_agent_status or arc_passport_draft, nor does it mention exclusions or prerequisites.

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 full burden. It discloses the cost ($0.003 per call), the payment mechanism (x402), and the two-step process. It also states what it checks and that it compares against expectations, making the behavior transparent.

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 a single block but well-structured: it starts with the purpose question, lists checks, then cost and usage. No fluff, each sentence contributes to understanding the tool.

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 complexity of a two-step payment flow and no output schema, the description is remarkably complete. It explains the purpose, the checks, the cost, and the exact call sequence. An agent can correctly invoke this tool without additional context.

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 100%, so baseline is 3. The description adds workflow context, explaining that `payment` is a signed x402 payload that completes the purchase inside the call, and clarifies `expect` as expected amount in USDC. This goes beyond the schema's basic descriptions.

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 clear question that defines the tool's purpose: verifying whether an Arc payment landed. It enumerates specific checks (payer, recipient, amount in both transfer forms, confirmation, gas) against expectations, distinguishing it from other arc_* tools like arc_contract_check or arc_fee_flow.

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 provides explicit usage instructions: call once without `payment` for terms, sign with wallet, call again with `payment`. It implies this is for verifying payments and contrasts with other tools by focusing on payment confirmation. It doesn't name alternatives but the context is clear.

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?

No annotations are present, so the description carries the full burden. It discloses the data source (PoolManager events), the refresh interval (five minutes), the cost (free), and the exact output fields (first buyer, seconds, sold straight back, USDC depth, flags, leaderboard). This is thorough behavioral disclosure.

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 front-loaded with the title and a comma-separated list of outputs. It is efficient: each clause adds distinct information, and the data source/frequency sentence is short.

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?

The description enumerates all return fields despite lacking an output schema, and it states the update frequency and cost. Nothing critical is missing for a zero-input monitoring tool.

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 zero parameters, so the description has nothing to explain. Baseline 4 applies.

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: monitoring new Uniswap v4 pools on Arc, including first buyer details and metrics. It specifically mentions the resource (pools on Arc) and the action (watch), distinguishing it from generic pool tools.

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 context: it is for pools created in the last 24 hours and updates every five minutes. However, it does not explicitly compare to sibling tools or state when not to use it.

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 behavioral burden. It discloses what is measured, that measurements were taken 'this minute from our server,' and even notes the official RPC's throttling quirk. It does not state the output format explicitly, but as a zero-parameter read-only status tool, the disclosed behavior is largely 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?

Three short sentences pack the core purpose, data points, measurement window, and a practical use case with no wasted words. The front-loaded question-style opening immediately signals what the tool does.

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 zero-parameter status tool with no output schema, the description is complete: it states what is reported, how current the data is, where it is measured from, and why an agent would call it. Nothing essential is missing for selecting and invoking the tool.

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 zero parameters and the schema coverage is 100%, so there is no hidden input meaning to document. The description still adds value by explaining what the result conveys: latest block, lag, and response time.

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 identifies the resource (Arc RPC endpoints) and the action (report which one is answering and how fast, including latest block, lag, and response time). It distinguishes itself from sibling status tools like arc_agent_status or arc_faucet_status by focusing specifically on RPC performance rather than agents, faucets, or wallets.

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 gives a concrete use case: when Arc's official RPC throttles with a bug-like error, use this tool to pick another endpoint. It provides clear context but does not name explicit alternative tools or state when not to use it, though no sibling appears to cover RPC status.

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 well: it discloses pricing ($0.005/call), payment chains accepted (USDC on Arc/Base/Solana, XNT on X1), the x402 auth requirement, and that concentrated/shared-payout cases are flagged. It lacks detail on rate limits or failure modes, but covers the key behavioral traits.

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?

Dense but front-loaded: the ranking thesis leads, followed by what is returned, flags, and payment mechanics. Every sentence earns its place, though the payment-chain list and workflow sentence are packed tightly.

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 exists, so the description usefully enumerates the returned signals (payers, payments, USDC, concentration, liveness). Combined with pricing and the payment workflow, an agent has enough to call it correctly; only ranking order ties and error handling are unspecified.

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 100% and the single `payment` param is documented, so baseline is 3. The description adds genuine value beyond the schema by explaining the two-step x402 flow (fetch terms unsigned, then re-call with the signed payload), which the schema alone does not convey.

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 — ranking Arc agents by distinct OUTSIDE payers read from settlements — and immediately differentiates itself from reputation/market siblings via 'Track record, not price.' An agent can tell what this produces without opening the schema.

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 invocation workflow (call once without `payment` for terms, sign, call again with `payment`), but no explicit when-to-use or when-not-to-use versus siblings like arc_agent_reputation or arc_trust_check. Usage is implied by the ranking semantics rather than stated.

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 provided, the description carries the full burden of behavioral disclosure. It explicitly states this is a read operation ('read from the contracts') and notes it is free, which is useful cost/risk context. It also names the exact data being read, giving the agent a clear picture of what the call will do.

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 a single dense sentence that front-loads the core question, then specifies the exact data returned and the cost. Every phrase earns its place, and there is no filler or repetition of structured fields.

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 states the source (contracts), the data items returned, and the cost. An agent can invoke it without needing additional context about inputs, side effects, or return structure.

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 zero parameters and schema description coverage is 100%, so there is no parameter ambiguity. The description still adds value by enumerating what the response will contain, which partially compensates for the lack of an output schema.

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 identifies the resource (stablecoins on Arc) and the specific data points returned: USDC and EURC total supply, addresses, and EIP-712 signing domains. It does not explicitly contrast itself with sibling tools, but the scope is concrete enough to understand what the tool does.

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 gives no guidance on when to use this tool versus alternatives, and there is no mention of exclusions or related tools. While 'right now' implies current on-chain state, that is not enough to help an agent choose it among the many Arc-related siblings.

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?

No annotations, so the description carries the full behavioral burden and does so well: it discloses pricing ($0.003/call over x402), accepted assets/chains (USDC on Arc/Base/Solana, XNT on X1), and the exact two-call auth flow (fetch terms without payment, self-sign, re-call with payment). It omits failure/error behavior and rate/limit characteristics, but the core cost and settlement mechanics are transparent.

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?

Purpose is front-loaded and every clause maps to something an agent needs (what is measured, what to pass, cost, payment flow). The measurement list is dense and comma-heavy, making it slightly hard to parse, but there is little genuine filler for a tool of this complexity.

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 complex, paid, no-annotation, no-output-schema tool, the description is nearly sufficient: it names the measured outputs, the price, the asset/chain options, and the full payment handshake. It lacks any statement about failure modes or what a non-delivering verdict looks like, which is the main remaining 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 coverage is 100% and the single payment parameter is well documented in the schema, so baseline is 3. The description pushes past that by explaining the parameter's role in the staged flow (first call returns terms, second call with the signed payment completes the purchase) and what payload to use. It also references 'agent, address or url' inputs that are not present in the schema, a minor ambiguity.

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+resource (vet an Arc agent's actual delivery) and enumerates the concrete dimensions it measures: responsiveness now and over 7 days, response time, payment functioning, settled paid calls, and on-chain payer concentration. An agent can tell this apart from arc_agent_reputation and arc_payment_check by the empirical 'measured, not claimed' scope. It does not, however, explicitly name those siblings to sharpen the boundary.

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?

Opens with a clear usage trigger ('Before paying an Arc agent') and gives an operational context, plus the required two-step purchase flow. It gives no explicit when-not-to-use or named alternative, so it stops 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?

With no annotations, the description carries the full behavioral burden. It discloses that per-wallet estimates are paid calls ($0.003 via x402 or card pass) and adds a notable conflict-of-interest disclosure ('We hold UBI and say so'). However, it does not state that the tool is read-only, has no side effects, or describe rate limits or authentication, leaving important behavioral traits implicit.

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 a dense, run-on sentence with nested parentheticals and multiple topics (free data fields, paid call, website parity, holding disclosure). It front-loads the data fields but could be broken into clearer sentences. Some elements, such as the website-parity note, are terse, while the overall length is not excessive for the amount of information.

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 explain return values; it does by listing key data points (USDC waiting, payout list validity, USDC per 1M UBI, recent payouts). It also covers the paid per-wallet estimate path and a conflict-of-interest note. It omits what happens when address is omitted, but that behavior is strongly implied.

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 100%, so the baseline is 3. The description adds meaningful detail beyond the schema: the optional address parameter triggers a paid call at a specific URL, costs $0.003 via x402 or card pass, and returns the same numbers as the public website. This is useful semantic enrichment for the single optional parameter.

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 identifies the resource: UBI holder payout data on Arc, listing specific fields (USDC waiting, next valid payout list, USDC per 1M UBI, recent payouts). It does not name a sibling for differentiation, but the tool is unique among the large sibling set. The purpose is clear, though it lacks a direct verb like 'get' or 'list'.

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 distinguishes the free aggregate data this tool provides from the per-wallet payout estimate, which it explicitly marks as a separate paid call with URL and price. This gives clear context for when to use this tool versus the paid alternative. No explicit when-not-to-use condition or sibling tool is named, but the paid-call boundary is useful.

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 provided, the description carries the full burden. It explicitly states 'Read live from the chain' (indicating real-time data and read-only behavior) and discloses a rate limit ('Free, 200 calls a day'). These are important behavioral details not inferable from the name or schema. It also says 'Everything public', clarifying it does not return private data. This goes beyond a simple 'get info' and provides useful operational context.

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 front-loaded with the core value proposition ('Everything public about one Arc address in one call') and follows with a concise list of what is included. Every sentence provides information: the data types, the live read behavior, and the rate limit. There is no wasted wording or redundancy. It is visually structured with a colon and list, making it easy for an agent to parse.

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?

The description is comprehensive for a single-parameter tool with no output schema. It enumerates the types of data returned (USDC/EURC/APEX balances, contract status, ERC-8004 identities, x402 selling), which gives an agent a clear picture of the output's scope. It also mentions live-read and rate limits, rounding out the operational context. It doesn't specify the exact return structure, but since there is no output schema and the data types are listed, this is sufficient for an agent to infer the shape. One minor gap is that it doesn't mention whether the tool returns zero values or handles errors, but this is not critical for a read-only overview.

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 schema fully describes the single parameter 'address' as '0x address on Arc', so schema coverage is 100%. The description adds no new meaning beyond the schema—it merely refers to 'one Arc address' without providing additional format, validation, or example. Since the schema already covers the parameter semantics, a baseline score of 3 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 clearly states a specific verb ('get') with a resource ('everything public about one Arc address') and enumerates the specific data returned (USDC, EURC, APEX balances, contract status, ERC-8004 agents, x402 selling). It distinguishes itself from sibling tools like arc_contract_check (which focuses solely on contract status) and arc_agent_status (agent-specific) because it is a comprehensive single-call overview. The phrase 'in one call' also sets it apart from tools that might require multiple lookups.

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 implies usage as a one-stop-shop for address information ('Everything public about one Arc address in one call') but does not explicitly state when to prefer it over alternatives, nor does it mention when not to use it (e.g., if only contract status is needed, arc_contract_check might be more direct). There is no mention of alternative tools or exclusions, so usage guidance is implied rather than explicit.

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?

No annotations are provided, so the description carries full transparency burden. It discloses read-only behavior ('Reads only; you keep your keys'), refresh cadence (every 2 minutes), pricing ($0.02 per call over x402 with supported chains), non-advice disclaimer, and the two-step payment flow. The main gap is that it doesn't explain pagination or result limits beyond 'newest buys', but overall it's unusually thorough for a no-annotation 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 front-loaded with the core resource and frequency, then moves to behavioral and payment details. It's dense but every sentence contributes something, with no obvious filler. Slightly long for a single-paragraph description, but structured well.

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 read-only, no-annotation, single-param tool with no output schema, the description covers purpose, scope, freshness, return fields, payment mechanics, and legal disclaimer. An agent has enough information to decide whether to call it and how to handle the payment flow. Nothing critical 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 coverage is 100%, so the parameter `payment` is fully documented in the schema. The description adds context about how payment works (the terms-then-sign flow) and which assets are accepted, which complements the schema but doesn't add meaning beyond what's already covered. Baseline 3 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 names a specific resource and scope: newest buys by the 25 most profitable wallets of the last 24h, with size, time, wallet record and sell check. It is clearly distinguishable from sibling tools such as arc_whales or arc_fresh_launches, which don't promise copy-trade signals from profitable wallets.

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 gives a concrete usage procedure: call once without payment for terms, sign with your own wallet, call again with payment. That's clear and actionable. It doesn't compare against alternatives like arc_whales or arc_trust_check for evaluating wallet quality, but the procedural guidance is strong.

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 well: it discloses hourly refresh, the exclusion of launch insiders and bot-like wallets, the indexed pool scope (USDC pairs), the $0.01 price, accepted currencies, and the x402 auth flow. It omits return shape and rate-limit behavior, so it is strong but not exhaustive.

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 core ranking definition, followed by scope/exclusions and payment mechanics. Every sentence earns its place, though the payment paragraph is dense and could be split more cleanly.

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 or annotations exist, so the description must do the work, and it covers data scope, refresh cadence, exclusions, cost, and the auth flow. It stops short of describing the exact response structure, but for a paid listing tool it is largely complete.

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 100%, so the single `payment` param is documented structurally, but the description adds real meaning beyond the schema by explaining how the signed payload is obtained and that passing it completes the purchase in-call.

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 names a specific resource and scope: 'Arc wallets that made the most REALISED profit in the last 24 h (closed trades only, average cost)', plus the returned fields (win/loss, open cost, latest buys). This clearly separates it from siblings like arc_wallet or arc_pools.

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 two-step payment flow ('call once without payment for the terms, sign them, call again with payment') gives operational guidance, but there is no explicit statement of when to choose this ranking over sibling tools such as arc_pools or arc_fresh_launches.

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 provided, the description carries the full behavioral burden and does so thoroughly: it explains the counting methodology (EIP-3009 authorizations, Circle Gateway batches), the exclusion of plain transfers, the category definitions for facilitators, and the distinction between the free stats and the paid settlement endpoint.

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 mostly front-loaded, leading with the high-level question and then detailing the output shapes. Some phrasing is convoluted—'each measured and shown apart from the direct totals'—and the final sentence packs pricing, scope, and the API path together, slightly reducing readability.

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 there is no output schema, the description does an excellent job of enumerating what the agent will receive in both invocation modes: totals, facilitators and kinds, top sellers, paid amounts, payer counts, and facilitator paths. It also specifies cost and the bulk endpoint. Nothing critical for selecting or invoking the tool 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?

The schema already describes the address parameter with format details, and the description adds meaningful semantics by stating that an address can be looked up as seller or payer and what data is returned for that address. It goes beyond the schema's bare description but stops short of giving examples or clarifying edge-case behavior.

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 identifies the tool's domain—signed x402-style payments on Arc—and specifies the data source. It reads coherently as a payment-stats lookup, but it lacks an explicit verb like 'returns' or 'summarizes' and does not explicitly distinguish itself from sibling tools.

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 gives clear usage branches: without an address it returns aggregate stats, with an address it returns address-specific payment details. It explains what is excluded from the data, which helps an agent decide if this tool fits a query, though it does not mention when to prefer one of the sibling Arc tools.

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 well: it discloses the 15-minute refresh cadence, the $0.003 price, the accepted payment rails (USDC on Arc/Base/Solana, XNT on X1), the two-step x402 handshake (call for terms, sign, re-call with payment), and that withdrawal depth is read on-chain at the current block. These are exactly the operational facts an agent needs before invoking it.

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?

Purpose is front-loaded and no sentence is purely filler, but the payment sentence is dense and run-on, packing price, four currencies and the two-call flow into one long line. Slightly more structure would improve scannability without losing content.

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 or annotations, the description compensates by describing the returned fields, freshness and payment/auth requirements, so an agent can call it correctly. It omits failure/error behavior and any notion of result size or pagination for the full board, which is a minor remaining gap for a plain two-parameter tool.

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 100%, so the baseline is 3; the description adds value beyond the schema text by explaining that `vault` narrows the whole board to a single address and by spelling out the `payment` workflow (first call yields terms, second call completes the purchase). This meaningfully extends the terse schema descriptions.

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: it yields lending-vault metrics on Arc for the vaults Circle Earn Kit lists (Morpho Vault V2), and enumerates the exact data points returned (rate, size, realizable withdrawal, lending destinations, 24h trail). This is distinguishable from generic siblings like arc_pools or vault_heartbeat without opening the schema.

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 opening clause 'before you deposit' establishes the primary when-to-use condition, and the payment instructions give clear procedural context. It does not, however, name alternative siblings (e.g., arc_pools) or state when NOT to use it, so guidance is clear but not complete.

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 full behavioral burden. It does disclose useful traits: the content is drawn from the spec and deployed contracts, is cost-free ('Free.'), and spans a named topic set. It does not describe the return format or how the guide is structured, which for a no-output-schema informational tool is a minor gap.

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 purpose is front-loaded in the first clause ('How ERC-8004 works on Arc'), followed by a colon-delimited coverage list. It is a single dense sentence, slightly run-on, but every listed item conveys scope rather than filler.

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 zero-param, no-output-schema informational tool, the description is nearly self-sufficient: it names the topic, the source of truth, and the coverage areas. The only shortfall is the absence of return-shape or usage-routing detail, which is acceptable given the tool's simplicity.

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 takes zero parameters, so the baseline is 4. The description correctly implies no configuration is needed; there is nothing for the schema to document and nothing missing.

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?

It clearly states a specific purpose: an explainer of how ERC-8004 works on Arc, including the X1 registry location, sourced from spec and deployed contracts. It enumerates its coverage areas (registration, registration file fields, domain proving, agentWallet payments, reputation), which distinguishes it as a reference/guide rather than an action tool. It does not, however, explicitly contrast itself with closely related siblings like arc_agent_reputation or arc_agent_market.

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?

Usage is implied rather than stated — an agent can infer this is a documentation lookup to consult before doing ERC-8004 work, and 'Free' signals no cost. There is no explicit when-to-use vs alternatives guidance (e.g., 'call this before arc_agent_market'), leaving routing to inference.

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 must carry the behavioral burden. It does add useful context: the faucet route is free, requires only a signature, and needs no gas, and bridges are 'measured live.' Yet it does not explicitly state that this is a read-only informational guide or what the tool returns, leaving some ambiguity about whether it performs actions like claiming.

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 a single compact sentence that front-loads the core purpose and then enumerates the covered routes in a clear list. The repetition of 'Free' at the end is slightly redundant but not harmful, and the overall length is appropriate for a 0-parameter tool.

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 informational tool without an output schema, the description provides enough detail about the guide's contents to let an agent decide whether to invoke it. It names all major routes and even hints at cost nuances, so the agent can route the user appropriately even if exact output formatting is not specified.

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 input schema is empty with zero parameters, so the baseline is 4. There are no parameters for the description to explain, and the tool appears intentionally parameterless as a general informational guide.

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 identifies the tool's purpose: providing routes for getting USDC onto Arc. It lists specific methods (faucet, bridges, CCTP, Gateway, Onramp Kit), which distinguishes it from narrower sibling tools like arc_bridges or arc_faucet_claim, though it never uses a direct verb like 'shows' or 'explains.'

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 phrase 'every route we know works' implies this is the comprehensive guide for onboarding USDC to Arc, giving agents context on when to prefer it. However, it does not explicitly say when to use this tool instead of more specific siblings like arc_bridges or arc_cctp_cost, nor when not to use it.

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 burden, and it does well: 'How to accept' signals an instructional/read-only tool rather than a payment-execution action, and 'Free' plus 'verified on chain while doing it ourselves' gives useful context. It stops short of explicitly saying it returns a guide and has no side effects, but nothing in the text implies mutation or external side effects.

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 single sentence is front-loaded with the main purpose and then lists concrete content areas without fluff. It is slightly dense as one long sentence, but every component carries information and 'Free' is a meaningful one-word signal.

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 no-argument, no-output-schema informational how-to, the description provides enough detail to select and invoke it correctly: it names the network, payment asset context, and the main topics. It does not describe the exact return format or step-by-step structure, but that is not required for an agent to decide to call this guide.

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 zero parameters and 100% schema coverage, so there are no parameter ambiguities to resolve. The description adds useful topic-level context, which is the baseline expectation for a no-parameter tool.

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 verb and resource — 'How to accept x402 payments on Arc' — and enumerates exactly what the guide covers: signing domains, settlement logs, gas cost, and settlement options. The 'how_to' name plus content clearly separates it from the sibling x402 inspect/test/stats tools.

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 gives clear context for when to call it: when the agent/user needs instructions on accepting x402 on Arc, and it notes the information is on-chain verified and free. It does not explicitly name alternatives or say when not to use it, but its informational framing is enough to avoid confusion with sibling payment-testing/inspection tools.

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 burden of behavioral disclosure. It reveals that the tool is a read-only inspection operation, shows what data it extracts (terms, issues, payment methods), and discloses the rate limit (100 calls/day). This goes beyond a minimal description, though it could mention error behavior for non-x402 URLs.

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?

Two sentences with zero filler. The first sentence front-loads the user intent and core action, and the second packs high-value specifics (protocol version, networks, amounts, payment options, issues, rate limit) without redundancy. Every clause 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?

Despite having no annotations and no output schema, the description effectively explains what the tool returns (terms, issues, payment methods) and its usage context. Minor gaps remain, such as handling of invalid or non-paywall URLs, but for a two-parameter read-only tool the description is sufficient for an agent to call it correctly.

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 input schema already provides 100% description coverage for both parameters. The description adds no new parameter-level details beyond referring to the URL as an 'x402 paywall' and mentioning the address the payment goes to, which slightly contextualizes the URL parameter. This matches the baseline score for high schema coverage.

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 uses a clear verb-resource pair: 'Point it at any x402 paywall and get its terms read for you.' It enumerates specific outputs (protocol version, networks/assets, amount, address, payment options, issues) that make the tool's function unambiguous and distinct from nearby siblings like x402_payment_test or x402_accept_on_arc_how_to.

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 opening question 'How do I pay this URL?' provides immediate context for when to use the tool: when an agent has a URL behind an x402 paywall and needs to discover payment terms. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to route appropriately.

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