apex-x1

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

With no annotations, the description carries the full disclosure burden and does add real behavior: the call is 'Free', gas is sponsored ('gas on us'), and the reward is rate-limited ('one per tool family per 30-day season'). It does not state whether the call is purely read-only or whether invoking it mutates wallet state, leaving a meaningful gap 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?

It is a single semicolon-chained sentence, so nothing is wasted in length, but the front-loaded clause is the least informative part and the metaphor-heavy phrasing forces parsing before the actual function ('Returns the rules...') surfaces. Adequate but not cleanly structured.

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 or annotations, and only one optional parameter, so the description must be self-sufficient. It does say what comes back (rules, season, plate), but undefined domain terms ('APEX tools', 'Chef's Special', how the meal is forged) leave an agent without the vocabulary needed to interpret the result. Minimally 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% for the single optional 'plate' parameter, so the schema already documents type and meaning. The description's clause 'if you pass a plate number, that plate' restates rather than extends that, adding no syntax, format, or validation detail beyond the schema. 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 does name a verb and resource secondary ('Returns the rules, the current season and, if you pass a plate number, that plate'), so an agent can infer this is a status/query tool for a reward program. But the leading clause ('using APEX tools serves the paying wallet an on-chain meal NFT') describes the broader mechanic rather than what this tool itself does, and undefined jargon ('APEX tools', 'Chef's Special', 'dishes') obscures the purpose.

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 implies eligibility context ('serves the paying wallet', using APEX tools) and shows how the optional plate parameter changes behavior, which is useful implied guidance. However, it never states when to call it versus the many sibling tool-status tools, nor any exclusions or prerequisites in explicit terms.

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 is the sole source of behavioral disclosure. It hints at a read-only 'line-up' and 'played back as notes,' but never explicitly states that the tool is read-only, whether it returns data, or what side effects it might have. This is insufficient for a tool with zero annotation 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?

The description is just two sentences with no fluff, and the core subject appears first. The metaphorical phrasing is slightly less efficient than a direct statement, but it still fits within a compact 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?

For a zero-parameter, no-output-schema tool, the description covers the main content ('which agents have a song, and their wallets' and 'on-chain history played back as notes') but does not provide a concrete return format or example. It is acceptable but has clear gaps.

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 an empty input schema, so there is nothing the description needs to add about parameters. Per the baseline rule for 0-parameter tools, this gets full credit.

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 resource ('the city radio line-up') and indicates it shows which agents have a song and their wallets, but it never uses a clear verb such as 'get' or 'list'. It is vague about whether this returns a directory, plays content, or otherwise, and it does not distinguish itself from the sibling 'agent_tune'.

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?

There is no guidance on when to call this tool versus alternatives such as agent_tune or agent_vault_status. The description only describes the content, not the conditions that would make this the right choice.

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 behavioral disclosure, but it only mentions determinism and the empty-history case. It does not state if the operation is read-only, the format of the output (e.g., audio data, URL), or any side effects. This is insufficient for a tool with no annotation support.

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 brief and front-loaded with the core purpose. The opening 'Hear yourself.' is stylistic but not essential, and the rest efficiently conveys the transformation and edge case. It earns a high score for structure and lack of verbosity.

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 the tool's simplicity, the description omits key context: what the agent receives as a result (e.g., a tune object, audio data), any failure modes, and whether it is a read operation. With no output schema, the description should clarify the return value, but does not. This leaves an agent uncertain about the outcome.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% and the only parameter 'wallet' is just a string. The description implies it is a wallet address, which adds minimal meaning, but it does not specify format, required network, or any constraints. The description compensates only slightly for the missing schema details.

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 action: turning a wallet's on-chain transaction history into deterministic music. It also provides a meaningful edge case (empty history yields no song), which clarifies the resource and behavior. This distinguishes it from siblings like agent_radio implicitly by its unique transformation of transaction history.

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 guidance is given on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or comparisons to siblings. The description only explains what it does, not when to invoke it, leaving the agent to infer usage.

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 explains the vault mechanics (deposit XNT, profit lifting share price) but does not explicitly state that the tool is read-only, safe to call, or any side effects. For a status tool, this is adequate but not exhaustive; it lacks explicit statements about immutability or side effects beyond the data itself.

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 with no fluff. The first sentence front-loads the key status fields, and the second adds explanatory context about how the vault works. Every word 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?

Given zero parameters and no output schema, the description lists the primary data points returned (pool balance, share price, performance fee, immutability). It also explains the deposit and profit mechanics. It may not enumerate every possible field, but it covers the essential information an agent needs to understand what to expect. A 4 is appropriate as it is mostly complete but could explicitly mention units or additional fields.

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 baseline is 4. The description does not need to explain parameters, and it correctly focuses on what the tool returns rather than inputs. No parameter information is 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?

The description clearly states the tool provides live status of the APEX agent trading vault, listing specific data points (pool balance, share price, performance fee, immutability). It distinguishes itself as a status tool, though it does not explicitly name alternatives like vault_heartbeat. The verb 'status' and resource are specific.

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 by describing what it returns, but it does not provide explicit when-to-use guidance or exclusions. With sibling tools like vault_heartbeat and other status tools, an agent might need more direction on when to choose this tool over others. The context is implied but not 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, the description carries the full burden, and it does disclose meaningful traits: the challenge signing needs no gas and no transaction, and the faucet claim needs no captcha. However, it says nothing about what the tool actually returns (a guide? steps? state?) or any prerequisites like wallet requirements, leaving real gaps 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?

Two sentences, front-loaded with the value proposition and then the sequence of steps. Dense but every clause (no gas, no transaction, no captcha, zero-cost) earns its place; nothing is wasted.

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 instructional tool with no output schema or annotations, the description lays out the full onboarding path and its cost profile. What remains missing is the return format and any alternative routing, but the core context is covered.

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 there is nothing to document and the baseline of 4 applies. No parameter-related guidance is needed or expected.

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 multi-step flow (register, sign challenge, become verified, claim free APEX from faucet) with a clear resource and scope. It is easy to distinguish from most siblings, but it does not differentiate itself from closely related onboarding tools like start_here or get_onto_x1, which likely cover overlapping ground.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives a clear use condition: 'for an autonomous agent with no funds' and 'the zero-cost way to start on X1'. It signals the intended audience and cost profile well, but never names when NOT to use it or points to an alternative sibling (start_here, get_onto_x1) for agents who already have funds.

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 must carry the full burden of behavioral disclosure. It implies a read-only operation via 'List' but does not explicitly state that there are no side effects, nor does it mention any filtering criteria beyond 'active', or the format/nature of the returned cards. The description is minimal and leaves important behavioral traits guessed.

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, focused sentence that states the action directly. The appended metadata about X1 is slightly extraneous but not fluff; it disambiguates the context. No 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?

For a zero-parameter read-only listing tool with no output schema, the description states the core purpose but leaves gaps: it does not mention what fields/details are returned, whether the list is limited/paginated, or clarify why a user would need this. It suffices for simple use but could be more supportive.

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 there is no parameter detail to add. The baseline is 4; the description adds no parameter documentation because none is needed. The context about the Agora is relevant and helpful even without parameters.

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 ('List') on a specific resource ('active AI agent cards on the Citizens Agora'), giving a clear verb, object, and context. It distinguishes itself from sibling tools like agent_radio or agent_tune by focusing on listing cards rather than engaging with a specific agent.

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 guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, intended scenarios, or cases where another tool would be more appropriate. The description only states what it does, not when to choose 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 at all, the description must disclose behavior, and it does provide meaningful details: the cost is $1, XNT conversion uses the live rate at read time, and it returns x402 payment details. However, it does not clarify side effects (if any), authentication/contact requirements, or what happens with the inputs, so transparency remains partial.

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, front-loaded with purpose then pricing then return value. Every sentence adds information and there is no 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?

Although the purpose and pricing are stated, the description is incomplete for invoking the tool correctly: no parameter semantics, no output structure, no usage scenario, and no annotations. With 7 parameters, 0% schema coverage, no output schema, and no annotations, more context is needed for an agent to confidently call this 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 0% and the description maps almost none of the 7 parameters. The mention of chains and USDC could imply 'chain' values, but agentName, contact, priceUsd, description, agentAddress, and capabilities are left entirely to naming inference. For a 7-parameter tool, this is a meaningful gap.

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 identifies a specific action ('Get instructions'), a specific resource ('posting your agent card to the Agora'), and the return content ('x402 payment details'), making the tool's function unambiguous. It is clearly distinct from adjacent Agora or how-to tools by naming the exact post-instructions purpose.

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 clear that this is the tool to consult for posting an agent card to the Agora and includes relevant costing context. It does not explicitly state when not to use it or name alternatives, but the context and tool name are sufficient to route an agent to 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. 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 full burden, and it does so well. It discloses that the check is a simulation ('nothing spent'), details the return values (sell success, cost, depth, flags), and states rate limits ('ten a minute'). This is thorough behavioral disclosure for a read-only check tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but well-structured: purpose first, then method, output, and constraints. Every sentence contributes necessary context, though it is slightly verbose. It earns a 4.

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 what the tool returns, the method used, and rate limits, making it sufficient for an agent to decide whether to call it. It does not mention error cases or prerequisites, but for a free single-token check with no output schema, this is reasonably complete. A 4 reflects minor missing edge-case 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?

Schema coverage is 100% for both parameters, so the schema already documents the input formats. The description adds no extra parameter-level detail beyond restating the token/pool ID format and test size. 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 states a specific verb (check exit) and resource (token/pool on Arc), and clearly explains the simulated round-trip check. It distinguishes itself from generic exit_check by specifying 'on Arc' and from arc_exit_check_bulk by implying single-token checks. The purpose is unambiguous and actionable.

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 clarifies the input scope (token address or v4 pool id on Arc) and mentions rate limits, but it does not explicitly mention when not to use this tool or point to alternatives like arc_exit_check_bulk for batch checks or exit_check for other chains. Usage context is clear but exclusionary guidance is missing.

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. It reveals the operation is paywalled, the exact price, accepted payment currencies, the endpoint, and the sorting behavior. It does not cover authentication or side effects, but the output is payment instructions and the operation appears read-only, so disclosure is strong.

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 front-loads the critical paywall warning, then states limits, sorting, output, pricing, and the free alternative. Every clause earns its place and there is no 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 one-parameter tool with no output schema, the description covers input limits, output shape, cost, payment options, and the free alternative. A minor gap is that it never fully defines what an 'exit check' is, but the sorting categories and sibling context make the intent clear.

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 ids parameter is already documented. The description adds useful context about the 25-item limit and the worst-first sorting, but does not need to explain the parameter further.

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: performing bulk exit checks on up to 25 Arc tokens or pool ids, sorted worst-first. It clearly identifies the resource and the output (x402 payment instructions), and distinguishes itself from the single-check sibling 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 explicitly tells the agent when to use this bulk tool versus the free single-check alternative: 'Single checks are free via arc_exit_check.' It also flags the paywall and cost upfront, giving clear decision guidance.

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?

With no annotations, the description carries the full burden. It usefully discloses the cost model ($0.006 per call over x402) and that the safety score comes from a 'real round trip' rather than a static heuristic, which is meaningful behavioral context. It stops short of describing failure modes (e.g., what happens if the token is not sellable or the payment is rejected) or any 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?

A single dense sentence with parenthetical groupings that front-loads what the agent gets (sellability + owner powers) and ends with cost. Every clause carries information; the nested parentheticals are slightly heavy but not wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description does a reasonable job of describing the return surface (safety score, pool fee, hook, owner powers) and the paid-invocation model, which is what an agent needs to call it. It omits error behavior and does not clarify what the 0-100 score means at its boundaries.

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 (token, payment) are already documented in the schema, including the x402 payload flow. The description's mention of x402 pricing does not add 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 resource (an Arc token) and enumerates exactly what is returned: a 0-100 sellability/safety score from a simulated round trip, plus pool fee, hook, and owner capabilities (mint, pause, blacklist, upgrade). It is clearly distinct from token_lookup, arc_contract_check, or arc_hook_risk, but it never names a sibling to route the agent explicitly.

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 'Everything about an Arc token in one call' implies this is the consolidated one-stop check, which implicitly positions it against narrower siblings. However, there is no explicit when-to-use/when-not or named alternative, so selection guidance is left 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 carries the behavioral disclosure burden. It explains the nature of an assay (a reverted buy-and-sell), the contract address, and the fee's destination when creating one. However, it does not disclose the tool's own behavior (e.g., whether it is read-only, pagination, error cases, or output format). The description focuses on the assay concept rather than the tool's execution.

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 informative but slightly dense. It defines the assay concept, provides a contract address, and explains how to create an assay—information that may be tangential for a read tool. However, every sentence adds context, and it is not overly verbose. The core read functionality is stated early, and the later details are supplementary.

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 does not explicitly state the return format. It implies the read returns verdict, round-trip cost, and streak from the assay definition, but it does not confirm the output schema or any potential pagination. Given the tool takes an optional token and has no output schema, the description should clarify what the caller receives. The instruction about creating an assay via contract call is additional context but not directly relevant to the tool's interface.

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 describes the single parameter as 'Optional token address to read assays for.' The description adds meaningful distinction: if a token is provided, you read that token's assay; if omitted, you read all pools. This clarifies the parameter's behavior beyond the schema and directly maps to the two use cases.

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: 'Read every pool's last assay and streak, or one token's.' This is a specific verb (read) and resource (assays), and it also defines what an assay is. While it doesn't explicitly name a sibling tool, the unique concept of 'on-chain assays' distinguishes it from the other Arc-related tools like arc_exit_check 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 description says when to use the tool ('Read every pool's... or one token's') but does not provide explicit exclusions or name alternatives. It indirectly suggests that creating an assay is done via a direct contract call ('To make one, call assay(poolKey, 0)...'), implying this tool is for reading, but it never compares to other tools or states 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?

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, the description carries the full burden and does a good job: it discloses the $0.004 cost, accepted payment tokens, the two-step signing flow, and the side-effect that including `payment` completes the purchase inside the call. It leaves some mechanics (e.g., what the 'real sell probe' actually does) unspecified.

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 information-dense sentences with the purpose front-loaded and no filler. Minor ambiguity: 'One call, one 0-100 answer' sits awkwardly against the later instruction to call once without payment and again with payment.

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 paid, two-step tool with no output schema, the description covers the verdict scale, inputs, pricing, payment rails, and the required call flow. It doesn't say what happens when neither `pool` nor `token` is supplied, but the schema already documents the either/or relationship.

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 by explaining that omitting `payment` yields the terms while including it completes the purchase within the same tool call. It doesn't add new meaning for `pool` or `token`, but those are already documented in 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 clearly frames the tool as a buy/no-buy verdict for an Arc pool and specifies the output (0-100 answer) and inputs considered (hook permissions, sell probe, prior buyers). It does not explicitly differentiate from sibling tools like arc_hook_risk or arc_pools, so it stops short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives clear usage context ('Should you buy this Arc pool?') and an explicit two-call procedure: call without `payment` to get terms, sign, then call again with `payment`. It does not name alternative tools or 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 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 behavioral burden. It discloses that the operation is a simulated buy+sell in one block, that it returns the ETH received, the round-trip cost, and the revert reason if a leg fails. It also reveals the $0.01 x402 fee. It does not explicitly state that no real funds move, but 'simulated' strongly implies 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?

The description is compact and information-dense, front-loading the purpose and then explaining execution, return values, and pricing. The opening rhetorical question adds slight redundancy but is not wasteful; every other sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a paid, simulated tool with no output schema and no annotations, the description covers the essential behavioral contract: what happens, what is returned, how failures surface, and the cost. Minor gaps remain, such as not explicitly mentioning the 'payment' parameter in the description and not stating whether payment is required up-front, but the schema covers the parameter itself.

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 some context around token address ('Base token') and payment ('$0.01 per call over x402 (Base USDC first)'), but it does not provide parameter-specific details beyond what the schema already documents.

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 ('Base token') and a specific verb+outcome ('Executes a buy and a full sell through its deepest Uniswap v2/v3/v4 WETH or ETH pool... and returns...'). It clearly distinguishes itself from siblings like exit_check by scoping to Base and to Uniswap pools, so an agent can tell what this tool does even among many similar exit-check 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 interrogative opening ('Can you get out of a Base token...') implies the use case, and the pricing note gives a precondition. However, there is no explicit guidance about when to prefer this over siblings such as exit_check, arc_exit_check, or exit_check_bulk, nor any stated exclusions or alternatives.

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 disclose two important traits: data provenance ('from real receipts') and the payment model ('$0.001 per call over x402'). It leaves out things like rate limits or failure behavior, but the cost/payment disclosure is meaningful context beyond the schema.

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, zero waste: the measurement and its coverage come first, the billing model second. Everything 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?

No output schema or annotations exist, so the description must describe the return: it says the result is a dollar cost with the L1 data fee included across three transaction types, which is most of what an agent needs. It doesn't specify the exact shape (e.g., per-type breakdown), 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?

Only one parameter and schema coverage is 100%, so the schema already fully documents the x402 payment payload. The description adds nothing about the parameter itself, which is acceptable given the schema does the work.

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 the specific resource (transaction cost on Base) and enumerates the covered transaction types (ETH transfer, USDC transfer, Uniswap swap) with the inclusion of the L1 data fee. This is specific enough to separate it from the sibling arc_gas, which covers a different chain.

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 (getting current real-world gas cost in dollars) but never states when to pick this over arc_gas or how to interpret it for a cost decision. The per-call pricing note gives billing context, not selection guidance.

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 disclose meaningful behavior: the $0.001 per-call price, the x402 payment model, and the fact that the purchase can complete inside the tool call. The 'forward-verified' qualifier also signals a trust semantic for reverse lookups. It still omits failure/error behavior, but the paid-call mechanics are well surfaced.

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 dense sentence followed by a short pricing clause; nothing is wasted and the dual-purpose lookup is front-loaded. Mildly long but 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 read tool with no output schema and no annotations, the description covers the return fields (address, owner, profile records, primary Basename) and the payment flow. Only edge-case behavior (unknown name, unset primary name) 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 baseline is 3. The description echoes the schema's dual meaning for `q` and clarifies that the reverse direction returns the primary name specifically, but adds little syntax or format detail beyond what the parameter descriptions already state.

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 verb+resource and spells out both resolution directions: a Basename to address/owner/profile records, and an address to its forward-verified primary Basename. That is far more specific than the bare name 'basename', though it doesn't explicitly differentiate itself from nearby lookup 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?

Two usage modes (forward and reverse lookup) are implied by the enumeration, so an agent can infer what inputs are appropriate. However there is no explicit when-to-use guidance, no mention of alternatives, and no note on what happens for unregistered names.

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 states the data is read live from the chain, lists what is returned, and explicitly warns that price is not synthesized from the home-chain value and is null when no pool exists. This is unusually honest about behavioral 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?

Three focused sentences: the first defines the scope, the second lists the return fields, and the third clarifies an important edge case about null pricing. Every sentence earns its place with no redundant wording.

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 output schema, the description enumerates all key returned attributes and explains the null-price behavior. For a single-optional-filter read tool, this is sufficient for an agent to select and invoke 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 schema already documents symbol as an optional filter with an example. The description adds context about what symbols look like (WSOL.X, USDC.X) but does not meaningfully expand on the parameter's semantics beyond the schema's existing 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 identifies a read-only chain query for assets bridged onto X1, names concrete examples (WSOL.X, USDC.X), and enumerates the exact return fields. This makes the tool's object unambiguous and distinguishable from generic token or market tools among the 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 clear context for when to use the tool: to determine whether a bridged asset is genuinely live on X1 and whether any trading pool exists. It also explicitly clarifies that an asset can be live yet have no market, but it does not name sibling alternatives 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 must carry the full transparency burden. It does disclose the paywall, cost ($0.025), and the API endpoint, which are valuable. However, it fails to clarify whether the tool returns the token data itself or just payment instructions, and it does not mention side effects or prerequisites. This ambiguity keeps it at a mid score.

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 brief and front-loaded with the primary claim, but the second sentence is slightly awkward in phrasing and could confuse the reader about the return value. It is still economical, earning a 4.

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 lack of annotations and output schema, the description must fully explain what happens on invocation. It does not: the relationship between returning 'top 200 X1 tokens' and 'payment instructions' is unclear, and the actual response format or flow is not defined. This leaves the agent unable to confidently call the tool without additional inference.

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 and schema coverage is 100%, so there is nothing for the description to explain. Per the calibration rules, the baseline for 0 params is 4, and the description does not need to compensate for missing parameter docs.

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 ('top 200 X1 tokens with full metadata') and a clear action ('returns'), which distinguishes it from vague alternatives. However, the second sentence about payment instructions introduces some ambiguity about whether the tool itself returns data or just instructions, lowering the score from a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool versus alternatives like top_tokens or token_lookup. It mentions 'PAYWALLED' but does not specify when it is appropriate over free options, nor does it name any sibling tool. The agent is left to infer usage.

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 full burden for behavioral disclosure. It does not mention that this is a read-only operation (though implied), nor describe pagination, limit behavior, error cases, or data ordering. Lacks caution about rate limits or potential overhead.

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 extremely concise (one sentence), but it is under-specified rather than efficiently concise. The length is appropriate, but the content is minimal; there is no front-loading of the most important usage constraints.

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 data retrieval tool with no output schema and only one required parameter, the description might be minimal but still lacks essential context like default behavior (returns recent candles?), max limit, and how to interpret timeframes. An agent could misuse limit or be unaware of the need for a specific mint format.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any of the three parameters. The meaning of 'mint' is obvious to a crypto domain but not explicitly stated; 'limit' and 'tf' are only defined by defaults and enum. With zero coverage)Skip the description is a non-compensating failure.

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 verb and resource ('OHLC candle data for a token') and lists the valid timeframes glassily. It doesn't name a sibling tool with similar purpose, but among the many siblings it is clearly distinguished by the resource type (candles).

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 no guidance on when to use this tool versus alternatives, when not to use it, or prerequisites. The context is minimal; an agent would not know if this is for recent price action or historical data, or if there are constraints like token must be a known mint.

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 of behavioral disclosure. It reveals that results include price in payable currency, USD estimate, real stock status, and non-custodial purchase steps—useful behavioral context beyond a simple list. It doesn't mention pagination or ordering, but for a browse 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 front-loaded with a compelling hook and quickly lists the item types and filters. It's slightly verbose but every sentence contributes: purpose, scope, included data, and usage instruction. The structure is logical and easy to scan.

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 browse tool with six parameters (all documented) and no output schema, the description provides sufficient context: it names the item types, the fields returned, and the filtering options. It doesn't specify pagination or sorting, but for a catalog browse that's a minor omission. The description is complete enough for an agent to call 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 description coverage is 100%, meaning every parameter (q, type, market, currency, max_price, availability) already has a clear description in the schema. The tool description only references 'Filter with q, type, market, availability, currency and max_price' without adding syntax, examples, or additional meaning. Baseline of 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?

The description clearly states the tool's purpose as a unified catalog for all purchasable items, listing specific categories (NFTs, pools, land, buildings, sponsorships). It distinguishes itself from siblings by explicitly instructing to 'Start here instead of querying six separate systems,' which differentiates it from more specialized tools like catalog_product.

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 strong usage guidance: it says to start here for broad buying needs and lists the filterable dimensions. However, it doesn't explicitly state when NOT to use it (e.g., when a known product ID exists, catalog_product might be more direct), leaving some inference to the agent. The clear 'start here' directive still earns a high score.

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 does explain the output contents (price, live stock, buy steps), which is useful, but it does not explicitly state that this is a read-only operation, whether authentication is required, or any side effects. For a simple product lookup the lack of explicit safety notes is a minor gap, keeping this at a moderate score.

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 tool's purpose and output, immediately followed by the ID format and a pointer to the sibling. There is zero redundancy or fluff; every word contributes to clarity.

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 tool with no output schema or annotations, the description covers the essential information: what it returns, the parameter format, and how to obtain valid inputs. It does not address failure modes or error handling, but these are not critical for a straightforward retrieval tool, so it is fairly 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?

The schema defines the 'id' parameter with a basic example, but the description adds significant meaning by explaining the ID format ('nft-listing:nft_8, nft-pool:<pool_id> or commodity:TOMATO') and reinforcing the source (catalog_browse). This goes beyond the schema and gives the agent concrete format expectations, so it adds real value.

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 ('retrieve'), resource ('product from the catalog by id'), and delivers concrete output (price, live stock, exact steps to buy). It explicitly distinguishes itself from the sibling catalog_browse by positioning itself as the detail lookup after listing, so an agent can clearly tell them apart.

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 directly instructs the agent to list products with catalog_browse to obtain IDs, thereby defining the natural workflow and the alternative tool. This is explicit when-to-use guidance with a named sibling, leaving no ambiguity about when to call this tool vs. the listing 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?

The description adds meaningful behavioral context: it explicitly states the city is not decorative and that every venue settles on-chain in APEX/nonce. However, with no annotations, it still does not state whether calling this tool is read-only, whether endpoints require subsequent actions, or what the returned data actually looks like.

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 brief sentences with no fluff. The first sentence states what the tool provides, and the second adds a meaningful on-chain settlement qualifier without repeating the name or schema.

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 list tool, this is functionally complete: an agent knows what it returns and the important semantic constraint that every venue settles in APEX. It would benefit from explicitly stating the return format or read-only nature, but nothing essential is missing for selecting and invoking 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?

This tool has no parametersable, and the description makes that unnecessary. It does not mislead about arguments, and the schema already confirms an empty parameter set.

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?

Clearly identifies the resource: places in Citizens City where an agent can actually spend, plus the endpoint for each venue. The key detail that these are functional, spendable venues rather than scenery distinguishes it from generic location or lore tools, though it is phrased as a noun fragment rather than an explicit imperative like 'Returns...'.

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 choose this over siblings such as catalog_browse, agora_list, or service_market. The phrase 'an agent can actually spend at' implies a use case, but the description never states when to use it, when not to, or how it relates to alternatives.

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 does disclose two important traits: no API key required and no custody (user signs their own swap). However, it does not mention transaction costs, slippage, failure modes, or whether this is a read-only quote vs an actual state-changing execution. The disclosed traits are useful but incomplete for a financial execution 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?

Two sentences, front-loaded with the core action and resource, followed by the two most important operational caveats. Every sentence earns its place and there is no 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-parameter tool with no output schema, the description covers the key operational constraints (no API key, no custody, self-signed). However, it does not clarify what the tool returns (e.g., a transaction payload, a signing request, or a confirmation) or what the agent should do after invoking it. Given the financial nature and the lack of an 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?

The tool has zero parameters, so the schema provides no parameter semantics. The description compensates by explaining the operational model: no API key, no custody, self-signed swap. This is sufficient for an agent to understand that no input parameters are needed and the tool likely returns instructions or a transaction to sign.

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 ('buys or sells') and resource ('commodities on X1 for APEX'), and distinguishes it from a generic swap by noting it is the on-chain AMM program. It is clear enough to separate from siblings like commodity_markets or commodity_price, though it does not name a sibling explicitly.

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 context: it is the actual execution tool for commodity swaps, as opposed to market data or swap-building tools. It does not explicitly state when to use this versus commodity_swap_build or commodity_markets, but the phrase 'the on-chain AMM program' gives a reasonable signal that this is the execution step.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It states it returns price, pool address, and reserves, which implies a read-only query, but it does not explicitly confirm read-only safety or mention any potential side effects, authentication needs, or rate limits. The output is described, but the overall safety profile is left 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 concise and efficiently structured in three sentences. The first sentence introduces the resource, the second explains the trading mechanism, and the third lists the output fields. There is no fluff or redundant information, and the key output info 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 tool with no parameters and no output schema, the description adequately covers the essential return fields and the domain. It clearly states what is returned and the trading mechanism. The only gap is the lack of mention about how this differs from the sibling 'commodity_price' tool, but that is more a usage-guidance issue. Overall, it is fairly complete for a simple read-only query 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 schema provides no parameter information. The description adds value beyond the empty schema by explicitly enumerating the returned fields (price in APEX per unit, pool address, reserves), which clarifies what the agent can expect from the output. According to the calibration, a zero-parameter tool gets a baseline of 4, and this description meets that.

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 returns live commodity market data—price in APEX, pool address, and reserves—for each good. It uses a descriptive verb (returns) and identifies the resource (commodity markets), making the purpose clear. However, it does not differentiate itself from the sibling 'commodity_price' tool, so it lacks explicit sibling differentiation.

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?

There is no guidance on when to use this tool versus alternatives like 'commodity_price' or 'commodity_swap_build'. No prerequisites, conditions, or exclusions are mentioned, leaving the agent to infer the appropriate usage context.

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 behavioral burden. It discloses the key return content (price, pool depth) and the single-commodity constraint, but it does not mention failure behavior for unknown commodities, value freshness, or quoting details. Adequate for a low-risk read-only lookup but not rich.

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 short sentences with zero filler. The return semantics are front-loaded, and the parameter guidance is immediately actionable. Every phrase 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 single-required-parameter lookup with no nested objects and no output schema, the description covers what the tool returns (price + pool depth) and how to call it correctly with examples. It is largely complete, only lacking output format details or edge-case behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, requiring the description to compensate. It explains that 'commodity' is a commodity name and supplies three exemplar values ('Tomato,' 'Truffle,' 'Voidbloom'), which meaningfully adds to the bare 'string' type in the schema, though it does not enumerate the full set of valid commodities.

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 it returns the price of a single commodity plus pool depth, scoped to APEX, which is specific and understandable. It differentiates from siblings (e.g., commodity_markets) via the qualifier 'one commodity,' though the verb is implicit rather than explicit.

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 direct invocation guidance: 'Pass the commodity name' with three concrete examples. However, it does not explicitly compare against sibling tools like commodity_markets or state when this single-commodity lookup should be preferred over alternatives; usage is implied 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, the description carries the full burden. It discloses the unsigned nature of the transaction, the self-signing requirement ('you sign with your own key and broadcast yourself — never custodial'), and the risk of shallow pools affecting price. These are key behavioral traits beyond the schema. It omits details like fees or revert behavior but covers the critical operational aspects.

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 concise sentences front-load the core purpose and then provide essential usage guidance and warnings. No filler or redundancy; every clause contributes to correct invocation.

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 lack of output schema, the description explains the return format (base64 unsigned tx) and the required user action (sign and broadcast). It also warns about price impact and directs to commodity_markets for pre-trade checks. It doesn't discuss failure modes or edge cases, but covers what an agent needs 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 description adds meaning beyond the schema by clarifying side semantics ('buy' spend APEX, 'sell' give commodity units) and amount interpretation ('buy: APEX; sell: whole units'). The schema already covers most parameters (80% coverage), so the description enhances rather than compensates, but it does so effectively.

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—'Build an UNSIGNED transaction to BUY or SELL a Citizens City commodity against APEX'—with a clear resource and on-chain AMM. It differentiates from siblings like commodity_markets (price/depth) and commodity_price (quotes) by focusing on transaction construction, and from swap_build by the 'Citizens City commodity' context.

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 instructs to 'Call commodity_markets first for prices and depth' and warns about shallow pools, establishing a clear precondition before use. While it doesn't name alternatives or state when not to use it, the workflow guidance is concrete and actionable.

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

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

With no annotations, the description carries the full burden and does so: it discloses the pay-per-call price ($0.005 over x402 with specific rails), the refusal-before-payment behavior for unfound companies, and the exact sign-then-resubmit payment workflow. These are precisely the behavioral traits an agent cannot infer from the schema.

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 and sources are front-loaded, then constraints, then payment mechanics, so an agent can stop reading early. It is information-dense but the payment sentences are long; a little tightening would help 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?

For a four-parameter query tool with no output schema and no annotations, the description covers the sources, the field-level contents of the response, the failure mode, the cost, and the full payment handshake. Nothing an agent needs to call it successfully 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 schema already documents lei, name, ticker, and payment, making 3 the baseline. The description adds genuine value by clarifying that name/lei/ticker are interchangeable entry points and by explaining the otherwise-opaque payment parameter's role in completing 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 states a specific verb and resource ('identity from the public registries') and names the two exact sources (GLEIF for legal name/LEI/jurisdiction/status/HQ/parents, SEC EDGAR for US filers with CIK, industry, and filing dates). This distinguishes it from adjacent siblings like domain_check, email_check, and token_lookup.

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 explicit input modes ('Pass name, lei or ticker') plus a clear exclusion ('Not sanctions screening or KYC'), which routes agents away from compliance-style tools. It also gives the two-step condition for payment that no other sentence could replace.

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 does disclose meaningful behavior: the analysis is derived from bytecode, supports Base/Arc, costs $0.004 per call over x402, and the payment param completes the purchase inline. It says nothing about latency, caching, rate limits, or what happens on unsupported contracts, leaving real gaps for a paid read 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?

Two compact sentences: a framing question plus the list of flags, then the pricing line. Front-loaded and free of filler. The rhetorical question opener is slightly unusual but earns its place by orienting the reader to the use case.

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 compensates by enumerating the flags returned. Combined with 100% schema coverage on all three params and the explicit price/payment note, an agent has nearly everything needed to call it. Only the response shape and error behavior remain 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 description coverage is 100%, so the schema already documents chain, address, and payment. The description reinforces chain scope (Base or Arc) and the x402 payment/pricing model but adds no format or validation detail beyond the schema. 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 gives a specific verb+resource: it answers what a contract owner can do to holders (mint, pause, blacklist, fees, limits, trading switch, upgradeable proxy, ownership) read from bytecode. The enumerated flag set makes the tool's scope concrete. It does not explicitly differentiate itself from adjacent siblings like arc_contract_check or arc_token_check, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied — call this when you want to assess the owner's powers over a token contract on Base or Arc. There is no explicit when-not guidance and no named alternative for related checks, so the agent must infer the right moment to reach for it versus contract_check or token_check.

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 of disclosing behavior. It mentions 'nothing is credited without a verified on-chain burn,' which is a key behavioral constraint (requires on-chain burn, likely a destructive/state-changing action). However, it doesn't disclose other behaviors like: whether the tool itself performs the burn, whether it requires prior actions (like having ingredients), what happens on failure (e.g., if burn doesn't verify), or the output format. The description gives one critical constraint but lacks comprehensive behavioral transparency.

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 concise (two sentences) and front-loads the core action ('get the exact burn spec, burn the inputs yourself, then claim the minted output'), making it easy to scan. The second sentence adds a critical constraint ('Nothing is credited without a verified on-chain burn'). No wasted words, good structure for quick comprehension.

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 provides a high-level process and a key constraint, but it's incomplete for an agent to correctly invoke the tool. It doesn't explain what recipeId is, whether it's required, how to obtain it (presumably from craft_recipes), or what the tool returns (e.g., a status, transaction hash). Given the tool has only one parameter and no output schema, the description should fill these gaps. The complexity is moderate (crafting a good), but the description leaves crucial procedural details unspecified (e.g., does the tool itself perform the burn? Or is it a two-step 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 schema has one parameter (recipeId) with 0% description coverage, meaning the schema provides no description for it. The tool description does not mention the parameter at all, so the agent learns the parameter's purpose only from its name ('recipeId' - presumably the ID of a craft recipe). This is insufficient; the description should clarify what recipeId refers to, whether it's required, and any format constraints. The description fails to compensate for the schema's lack of parameter documentation.

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 is about crafting a processed good on X1 with a specific process (burn spec, burn inputs, claim minted output). It distinguishes from sibling tools like craft_recipes (which likely lists recipes) by focusing on the execution of the crafting process, not just viewing recipes. However, it doesn't explicitly say 'crafting' as a verb for the tool action, but the context makes it clear.

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 this tool: when an agent wants to craft a processed good on X1. It provides a procedural flow (get burn spec, burn inputs, claim output), which gives context on the sequence of actions. However, it doesn't explicitly state when NOT to use it or name alternative tools like craft_recipes for browsing recipes. The guidance is clear but lacks explicit 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?

No annotations are provided, so the description carries full burden. It discloses that crafting is on-chain and involves burning tokens, which implies a read-only informational tool. However, it doesn't state whether this tool has side effects (it likely doesn't) or any rate limits. Also doesn't mention what the output format is (e.g., a list or table). Neutral but slightly incomplete.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.