agentdata-nl

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

With no annotations, the description discloses key behaviors: it returns a signed attestation, stores counterparty name as SHA-256, and disclaims guarantees or compliance verdicts. However, it does not clarify whether it writes any data or what the history report entails.

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, well-structured paragraph that front-loads the core purpose and adds necessary detail. It could be slightly more concise, but it earns its length.

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 complexity (5 params, nested objects, no output schema), the description explains the overall flow but omits the return structure beyond 'attestation'. The on-chain history and sanctions results are not explicitly linked to the output, leaving some uncertainty.

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 40%, but the description adds significant context: 'counterparty_name' is screened and hashed, 'expected.amount' is atomic USDC with 6 decimals, and 'payment.tx_hash' comes from a PAYMENT-RESPONSE. This compensates well for the schema's brevity.

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 verifies settlement on-chain, reports wallet history, screens sanctions, and returns a signed attestation. It is specific to sellers receiving agent payments, and distinct from sibling tools that focus on individual actions.

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 use when a seller receives an agent payment, but does not explicitly contrast with alternative tools or state when not to use it. No alternatives are named, leaving some ambiguity.

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 fully discloses behavioral traits: pay-on-code-arrival model, dynamic pricing, USDC via x402, no account/KYC requirement, and lawful use only. The polling mechanism with POST /agent/phone-code is also mentioned.

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 somewhat lengthy but front-loads the main purpose and each sentence adds essential information. It is well-structured but could be slightly more concise.

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 explains what the tool returns (a number and handle) and how to poll for the code. It covers the full lifecycle and expected behavior, making it complete for the tool's complexity.

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 value by clarifying that 'country' and 'operator' are optional, listing example service values, and summarizing the overall usage pattern ('Give a service and optional country/operator').

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: to buy a phone number for SMS verification. It specifies the verb 'buy' and resource 'phone number', and distinguishes itself from sibling tools like 'get_phone_code' by focusing on the acquisition step.

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 explains when to use the tool (for one-time code verification) and outlines the process. While it does not explicitly state when not to use it or list alternatives, the context and sibling tools make it 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 full burden. It details the return data (name, legal form, status, etc.) and search behavior (exact UID or name with max 5 candidates). It lacks mentions of rate limits or authentication, but is otherwise thorough.

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 paragraph, front-loaded with purpose and lookup methods, followed by a clear list of returned data. Every sentence adds value with no redundancy.

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

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

For a tool without output schema, the description adequately explains return fields and constraints ('Companies only'). It lacks error handling details but is otherwise complete for a lookup 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 description coverage is 100%, so the schema already explains the parameters. The description adds minor context (UID exact, name up to 5 candidates), not significantly 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 clearly states it is for Swiss company checks from the Zefix register, specifying two lookup methods (UID or name). It distinguishes itself from sibling tools like check_cz_company by targeting Switzerland.

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 for Swiss companies and excludes non-companies ('Companies only'). However, it does not explicitly mention when to use alternatives, though sibling tools provide that 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 full burden. It discloses that the tool queries two sources, returns authorisation details and warning-list entries, and notes the focus on firms. It does not mention rate limits or authentication, but the behavioral description is adequate for a simple lookup 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 well-structured, starting with a clear question and then detailing the function. It is concise but could be slightly tighter—e.g., the first sentence could be merged with the next. However, it remains efficient and informative.

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 fully explains what the tool returns: authorisation details (member state, competent authority, services, LEI) and warning-list entries with official references. It also provides usage context and scope. This is complete for its complexity.

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%; all three parameters are described in the schema. The description adds value by explaining how to search (by name, website, or LEI) and noting that website provides the strongest match. This goes beyond the schema's definitions.

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 specifies the tool's purpose: checking if a crypto firm is authorised in the EU. It names the specific registers (ESMA interim MiCA register and EU non-compliant entities warning list) and differentiates from sibling tools which check other jurisdictions or entity types.

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 recommends using this tool for 'Counterparty/scam check before sending funds to a platform.' It also states 'Firms only,' implying it is not for individuals. While it does not list alternatives, the context of sibling tools provides implicit 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 provided, the description fully discloses behavioral traits: it's a 'cheap' polling tool, paid per request, returns only changes and status, and explicitly states it does not involve execution, custody, or position sizing. This exceeds the burden of 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 extremely concise: three sentences, front-loaded with the core purpose, and no extraneous 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?

Given the simple tool with only 2 parameters and an output schema, the description covers everything needed: what is returned, how to use known_version, and the no-execution disclaimer. It is complete and self-contained.

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 valuable semantics: it explains that omitting known_version always returns changed=true, and advises to poll no earlier than next_check_after. This goes beyond the schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool as a lightweight polling mechanism for a previously retrieved crypto signal. It specifies the verb 'poll' and the resource 'crypto signal', and distinguishes itself from full retrieval by stating 'no full signal payload'. 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 provides clear context: 'for a crypto opportunity you already retrieved' and 'built for monitoring an active opportunity over time'. It implies when to use this tool versus full retrieval, but does not explicitly name sibling alternatives. However, the guidance is sufficient for correct 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?

With no annotations, the description carries full burden. It discloses return up to 5 candidates for name search, limit to companies, and open data source. It does not cover rate limits or auth, but these are not critical for a lookup 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?

Three sentences with clear, front-loaded purpose and no wasted words. Every sentence provides essential 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?

Given no output schema, the description adequately explains return values. It could mention result format or error handling, but overall comprehensive for a lookup 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% with clear descriptions. The tool description adds minimal extra detail beyond the schema, such as the source register. Baseline 3 is appropriate as schema already does heavy lifting.

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 is an official Czech company check from the ARES register, specifies lookup by ICO or name search, and lists the returned information. It effectively distinguishes from sibling tools by being country-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 when to use (for Czech company checks) but does not explicitly state when not to use or provide alternatives. The context of many sibling tools suggests its niche, but explicit exclusions would enhance clarity.

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 return fields (procedure type, status, dates, court, source reference), match-basis, coverage notes, and clarifies that 'no_match' means no publication in the searchable register. With no annotations, this adds significant behavioral 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?

Three sentences front-loaded with purpose and efficient detail. No unnecessary words, and every sentence earns its place. Structure is clean and scannable.

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 no output schema, the description covers return values, match semantics, and scope (companies only). It lacks details on pagination or edge cases, but given the straightforward nature of a lookup tool, it 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 67%, and the description adds value by noting that kvk_number is 'strongly recommended' and an 'exact match,' and that 'Best results with a KVK number.' It does not elaborate on city or name beyond the schema, but the added context improves parameter understanding.

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 checks Dutch bankruptcy/insolvency against the official Central Insolvency Register, listing specific procedures (faillissement, surseance, debt restructuring) and specifying 'Companies only.' It distinguishes from sibling tools that check other countries or companies.

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 advises 'Best results with a KVK number' and restricts to companies, providing clear context for use. It does not explicitly mention when not to use or list alternatives, but the scope is well-defined among sibling country-specific checks.

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 provided; description carries the full burden. It discloses the data source, output fields (status codes, bankruptcy/liquidation), and scope (companies only). Missing details on rate limits, authentication, or whether it is read-only, but still provides useful behavioral 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?

Single paragraph, front-loaded with purpose, then parameters, then output details. Every sentence adds information without redundancy.

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

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

For a simple lookup tool with 2 parameters and no output schema, the description covers purpose, input modes, output fields comprehensively. It could mention return format but is sufficient given the tool's straightforward nature.

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 descriptions. Description adds value: 'exact' for business_id and 'up to 5 candidates' for name, which are not in the schema. No enums or nested objects to elaborate.

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?

Description starts with 'Official Finnish company check from the YTJ register' – a specific verb and resource. It clearly distinguishes from sibling tools (e.g., check_ch_company) by specifying the country and data source.

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?

Description explains two lookup modes: by exact Business ID or name search (up to 5 candidates). It does not explicitly state when not to use or contrast with siblings, but the 'Companies only' qualifier provides some exclusion 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 provided, so description carries full burden. It discloses data source, return fields, and limitations (no director data). It does not mention rate limits or authentication, but for open data 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?

Two sentences, no filler. Front-loaded with purpose, then details. Perfectly concise for the information provided.

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 fully covers input, source, return fields, and limitations. Agent can confidently invoke this tool for French company checks.

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 both parameters described. Description adds context: SIREN is exact, name search returns up to 5 candidates. This enhances understanding beyond 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?

Description clearly states 'Official French company check from the INSEE Sirene register' and specifies lookup methods (SIREN exact or name search up to 5 candidates). It lists returned data fields, distinguishing it from sibling tools like check_ch_company or check_fi_company.

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?

Description mentions 'Companies only; no director or officer data', implying when to use and when not. It provides search method details but doesn't explicitly compare to other tools like check_fr_insolvency. Still, the purpose is clear enough for an agent to select 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?

The description discloses that the tool searches BODACC open data, returns judgment nature/date, court, publication date, and a BODACC link. It clarifies that a 'no_match' means no publication since 2008, not historical clearance, and that it covers companies only. No annotations are provided, so the description carries the full transparency burden and does it well.

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 paragraph that efficiently conveys all necessary information without extraneous words. It is well-structured, stating the source, what is searched, what is returned, and limitations. It could be slightly more concise, but it is effective.

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 simplicity (one required parameter, no output schema, no annotations), the description is remarkably complete. It covers input format, data source, return values (judgment details, BODACC link), date range, and limitations (companies only, no historical clearance). No gaps remain.

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 has 100% description coverage. The schema's description for the 'siren' parameter adds significant guidance: it specifies exact 9-digit match and recommends using check_fr_company for name resolution. This goes beyond basic type/requirement and helps the agent use the tool correctly.

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 as a French insolvency check against BODACC, lists specific procedures searched (sauvegarde, redressement, liquidation judiciaire, conciliation, professional recovery), and distinguishes it from sibling tools like check_fr_company by requiring a SIREN and suggesting name resolution first.

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 guidance on when to use this tool: you need a SIREN number, and it suggests using check_fr_company to resolve a company name to a SIREN. It does not explicitly state when not to use it or compare with other insolvency tools, but the context signals include many country-specific checks, implying this is for France only.

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 fully discloses the tool's data sources, return fields including bankruptcy flags, and that it is read-only. It does not mention auth or rate limits, but for open data 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 concise and well-structured, with a clear first sentence stating purpose, followed by parameter usage and return value list. 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?

Despite no output schema, the description lists all major return fields sufficient for decision-making. It could mention error handling or no-result cases, but for a simple lookup 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?

Schema coverage is 100% with detailed parameter descriptions. The description adds a bit of context (e.g., 'exact', 'up to 5 candidates') but mostly repeats schema info. 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 clearly identifies the tool as an official Norwegian company check from a specific register. It distinguishes from sibling tools by specifying 'Norwegian' and 'Companies only', and explains lookup methods and return fields.

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 states when to use the tool (Norwegian company lookup) and provides parameter options (exact number or name search). It does not explicitly state when not to use, but the context of sibling tools makes alternatives 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 burden of behavioral disclosure. It outlines returns (VAT status, REGON/KRS, address, account count, request_id) and the unique NRB verification feature. However, it lacks explicit statements on read-only behavior, authentication needs, rate limits, or error handling (e.g., invalid NIP). The description adds context beyond the schema but is not fully comprehensive.

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, with three sentences that front-load the tool's purpose and key features. Every sentence adds value: purpose, key capability, use case, and returns. No redundant phrases.

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 simplicity (2 parameters, no nested objects) and lack of output schema, the description covers all relevant aspects: what it does, when to use it, and key return fields. It misses explicit mention of error states or idempotency, but is largely complete for a lookup tool.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds minimal extra meaning, such as 'official Ministry of Finance register' and 'unique' account check, but does not clarify formatting or edge cases beyond what the schema provides. 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 clearly identifies the tool as a Polish VAT whitelist check using the official Ministry of Finance register, specifying it verifies VAT status by NIP and uniquely checks if a bank account (NRB) is registered. The verb 'check' and resource 'VAT whitelist' are specific, and the phrase 'the standard Polish invoice-fraud check before paying a supplier' distinguishes it from sibling tools targeting other countries or registries.

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 states the use case: 'the standard Polish invoice-fraud check before paying a supplier.' It also notes 'Companies only,' setting boundaries. However, it does not explicitly state when not to use this tool or mention alternatives like other country-specific checks, though the sibling context makes those implied.

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 input methods (issuer name, LEI, DTI) and return fields (issuer, home member state, authority, DTI, white-paper URL). However, it omits details like rate limits, authentication needs, or behavior on no match. This is adequate for a simple search 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, no wasted words. First sentence defines behavior and scope; second adds usage guidance. Efficient and 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 3 optional params and no output schema, the description explains what it does, what inputs are accepted, and what information is returned. It is complete enough for an agent to understand and invoke 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% with parameter descriptions. The description adds context that these are search keys and suggests using one of them. It doesn't add constraints or validation details, but the baseline is appropriate given the schema richness.

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 checks MiCA notification status by searching ESMA registers. It specifies the resource, search keys (issuer name, LEI, DTI), and return fields. This clearly distinguishes it from sibling tools focused on company/crypto checks.

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 a clear use case ('before trusting a stablecoin or token sold as EU-regulated'). It doesn't explicitly state alternatives or when not to use, but the context and sibling tools make the scope apparent.

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 must carry the full burden of behavioral disclosure. It states the tool is 'official' and lists return fields, but does not mention authentication requirements, rate limits, error behavior (e.g., what if company not found), or that it is a read-only operation. The description is insufficient for a tool relying on an external register.

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 at around 70 words across two sentences. It front-loads the core purpose and then enumerates returned data. While the list of fields is somewhat lengthy, it remains readable without unnecessary 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 lack of output schema, the description partially compensates by listing return fields. However, it does not specify the response format (e.g., JSON), error states, or pagination (none expected). For a tool in a suite of similar country checks, the completeness is adequate but not thorough.

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 both parameters described. The description adds value by clarifying that company_number must be exact and name returns up to 5 candidates. This contextual guidance improves parameter usage beyond the schema alone.

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: official UK company check from Companies House. It specifies exact lookup by number or name search, and lists all returned data fields. The scope ('Companies only') and the variety of sibling country-specific tools make the purpose unambiguous.

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

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

The description implicitly indicates use for UK companies by naming the register and listing typical UK company attributes. It does not explicitly state when to use this tool vs others (e.g., for other jurisdictions), but the sibling tool names (e.g., check_fr_company) provide strong contextual cues. Clear but lacks explicit alternatives 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?

No annotations provided, so description carries full burden. It explains the tool combines availability monitoring, on-chain history, and regulatory status, and states it is factual only. This covers the behavioral traits adequately for a read-only check.

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 conveys all necessary information without being overly verbose. It could be slightly more structured, but it is concise and 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?

Given the complexity (multiple data sources, no output schema), the description is quite complete. It specifies timeframes, data types, and limitations ('not being monitored is not negative'). It provides sufficient context for an agent to understand the tool's scope.

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%, baseline 3. The description adds meaning by explaining what each parameter is used for (e.g., '0x-address that receives the payment' for pay_to, 'URL of the x402 service' for resource), adding 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?

The description clearly states the tool's purpose: 'Trust check before paying an unfamiliar x402 service, by pay_to address and/or service URL.' It specifies the inputs and what data it combines, distinguishing it 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 implies when to use ('before paying'), provides context on data sources, and clarifies that it is factual only with no scores. However, it does not explicitly mention when not to use or list alternative 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?

No annotations are provided, so the description carries full responsibility. It discloses that the tool is 'free', implies a real-time feed ('every published advice change'), and explains pagination via cursor. However, it does not mention rate limits, authentication details, or error conditions.

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 conveying all key information. While effective, it could be slightly better structured (e.g., separated sentences for prerequisites, pagination, and alternatives). No unnecessary 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?

Given the tool's complexity (feed with filtering, pagination, and multiple change types), the description covers prerequisites, pagination mechanism, optional filters, and cross-reference to paid endpoint. Output schema exists, so return values are documented separately.

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 descriptions for all 4 parameters. The description adds significant value beyond the schema by explaining the purpose of cursor ('omit to continue from your subscription start, 0 for the backlog') and the kinds filter list. This enables correct invocation.

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 every published advice change since a cursor from a prior subscription, covering all coins. It lists specific event types (new signals, classification flips, etc.), clearly distinguishing it from subscription (crypto_feed_subscribe) and single-signal retrieval (get_crypto_signal).

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 instructs to send back next_cursor each time, and directs to get_crypto_signal for full advice behind a signal_id. It implicitly states prerequisites (must have subscribed) and provides clear context for 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?

With no annotations provided, the description fully carries the behavioral disclosure burden. It discloses the subscription duration (30 days), the returned handle and cursor, that polling is free and unlimited, and details the types of changes published (new signals, classification flips, status changes, score/entry-zone changes). It also notes that full advice is a separate paid call. No contradictions.

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 well-structured and front-loaded with the key action and duration. It then explains return values and subsequent usage. While slightly verbose, every sentence adds value. It is concise enough for an agent to quickly understand core functionality.

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

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

Given the tool has no parameters and an output schema exists (though not shown), the description covers subscription behavior, duration, return type, and subsequent polling. It is complete for a subscription tool, though a brief note on cancellation or renewal would improve completeness. Overall, sufficient for an agent to use correctly.

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

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

The input schema has zero parameters, so baseline is 4. The description adds meaning beyond the empty schema by explaining what the tool does, what it returns, and how to use the subscription. Since there are no parameters, the description replaces parameter documentation entirely.

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 (subscribe), the resource (change feed behind /crypto/scan), and duration (30 days). It specifies the scope (all coins) and differentiates from related tools like crypto_feed_since by indicating that polling is separate. This provides a specific verb-resource pair with clear distinction 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 implies when to use the tool: to get notified of changes in the crypto scan feed and 'be first to know when the market state flips'. It also mentions that after subscribing, polling via /crypto/feed/since is available and free. It does not explicitly state alternatives or when not to use, but the context from sibling names and the description itself gives sufficient 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?

No annotations are provided, so the description carries the burden. It discloses the tool is a factual measurement with wide error bars and not investment advice, but does not mention authentication needs, rate limits, or any destructive 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?

The description is concisely structured: it first states the purpose, then parameter guidance, then the return fields, and finally context. Every sentence is informative and adds value without redundancy.

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

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

Given no output schema, the description explains the return fields (trades, wins, win rate, average net return) and provides context (measurement start, window clamping, not advice). It is complete for the tool's low complexity, though it could mention error handling or data freshness.

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 only parameter 'days' has full schema description coverage (100%). The description repeats the default and clamping from the schema, adding no new semantic meaning beyond what is already in the input 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 states it provides a measured track record of strategies behind /crypto/verdict, specifying verb (track record) and resource. It differentiates from sibling 'crypto_verdict' by noting it's a cheap showcase for that paid endpoint, though not explicitly listing 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?

The description gives context on when to use: as a cheap showcase before paying for the verdict. However, it does not explicitly state when not to use this tool or provide alternatives beyond implying the main verdict is paid.

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 bears the burden of disclosure. It reveals the resold signal source, the two layers with their respective output types, the behavior when no fresh verdict is available (400 response and no charge), and a disclaimer that it is 'factual model output, not investment advice'. This is comprehensive.

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 and then adds supporting details about layers, billing, and disclaimer. Every sentence contributes necessary information without redundancy. It is slightly long but efficient given the complexity of 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 no output schema and only 2 parameters, the description sufficiently covers the tool's purpose, input parameters, behavioral nuances (billing, error condition), and output structure for both layers (confidence, summary, risk for long; entry, stop-loss, take-profit, reward:risk for daytrade). No gaps are apparent.

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 value beyond the schema by explaining the 'coin' parameter with an example and mentioning error-based discovery of supported coins. For 'layer', it clarifies that 'regime' is an alias for 'long' and reiterates the no-charge condition, providing meaningful context.

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 provides a 'live crypto trading verdict for a coin', specifies two distinct layers ('long' and 'daytrade'), and mentions it is 'resold from an upstream signal system'. This differentiates it from sibling tools like check_crypto_signal and crypto_track_record by emphasizing the verdict structure and source.

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 explains when to use the tool (to get a verdict) and provides important context about billing ('no fresh verdict means 400 and no charge'). However, it does not explicitly state when NOT to use it or compare to alternatives, leaving some room for ambiguity in tool selection.

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 provided, so description bears full burden. Describes return values (deviation, source values, timestamps) and confirms it's a read-only query.

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 with no redundancy. Front-loads purpose and key 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?

Adequate for a parameterless tool with no output schema. Covers purpose, output, and use case. Lacks data freshness note but acceptable.

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?

No parameters; description adds meaning by explaining output content beyond empty schema. Baseline 4 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?

Description clearly states the tool monitors EURC peg by comparing ECB reference rate to on-chain price, with specific outputs. Differentiates from all 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?

States 'No input required' and explains it's for agents holding/pricing EURC. Lacks explicit when-not-to-use but 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?

Without annotations, the description carries the burden. It explains that the $0.01 fee is not a purchase and that there is no promise the feature will be built. It also mentions that optional parameters like max_price_usd affect ranking. No contradictions.

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 fairly concise, covering main points in a few sentences. It front-loads the purpose but could be more structured with bullet points or clearer separation of ideas. Still, it's not overly verbose.

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 an output schema present and 5 parameters (1 required), the description provides enough context: purpose, fee explanation, alternative, optional parameters. It does not detail return values or errors, but output schema likely covers that.

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 good descriptions, so baseline is 3. The description adds extra meaning by explaining the fee motivation, typical kind values, and that budget-backed intents outrank others. This goes 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 clearly states the tool's purpose: to file a request for a capability that is not yet available. It uses specific verb 'File' and resource 'what you want to buy', and distinguishes itself from siblings implicitly by being a unique action among many checking tools.

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

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

It provides context on when to use (when you want something not buyable) and lists optional parameters. It mentions a free alternative (POST /agent/request) and describes the fee's purpose. However, it could be more explicit about scenarios where this tool should be avoided in favor of other tools.

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

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

With no annotations, the description carries the full burden. It discloses that measurements are real and never fabricated, that short windows have wide error bars, and that it is paid per request. These are useful but incomplete; side effects, rate limits, or authorization needs are not mentioned.

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 somewhat verbose, listing multiple populations and metrics. It front-loads the main purpose, but the lengthy enumeration could be more concise. Each sentence adds value, but the structure could be improved for 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 the presence of an output schema, the description adequately explains the key returned data (populations, win rate, etc.) and includes caveats. It covers the essential aspects for an agent to understand what the tool does, though sibling differentiation would strengthen completeness.

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 covers the single parameter 'signal_id' fully, including a pattern and example. The tool description adds general context but does not enhance parameter semantics beyond what the schema already provides. Baseline 3 is appropriate due to 100% 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 that the tool returns 'Historical evidence behind a crypto opportunity' and enumerates specific metrics, indicating a retrieval function. However, it does not explicitly differentiate from siblings like 'crypto_track_record' or 'crypto_verdict', which may have overlapping purposes.

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. The description purely states what the tool does without any context on when it is appropriate or when to avoid it, leaving the agent to infer usage indirectly.

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 the opportunity_score is a heuristic (not probability), that the tool provides market intelligence only (no execution, custody, or position sizing), and that it is paid per request with 400 for unknown IDs. This is good behavioral context, though rate limits and authentication are not mentioned.

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 core purpose and lists many fields, but remains well-structured with clear sentences. It is slightly verbose but every sentence adds value, earning 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 the single parameter and presence of an output schema, the description is complete. It covers prerequisites (signal from scan), return fields, and constraints (no execution, paid). No important gaps are apparent.

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 description adds meaningful context beyond the schema: the signal_id format example, stability across versions, and error handling (unknown ID returns 400 without charge). This enriches understanding of 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 clearly states the tool retrieves a specific crypto signal by signal_id and lists many fields it returns. It distinguishes from scan_crypto_market by specifying it is for individual signal retrieval, but it does not explicitly differentiate from similar sibling tools like check_crypto_signal or validate_crypto_signal.

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 mentions that the signal comes from /crypto/scan and is for market intelligence only, providing some usage context. However, it does not explicitly state when to use this tool versus alternatives like validate_crypto_signal, nor does it specify prerequisites beyond having a signal_id.

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 is the sole source of behavioral disclosure. It reveals that the tool is free and that it involves polling until a condition is met. However, it does not disclose potential timeout, maximum attempts, or what to do if the code never arrives. Given the simplicity, the disclosure is adequate 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?

The description is extremely concise, consisting of a single sentence that perfectly conveys the tool's purpose and usage pattern. It is front-loaded with 'Free:' and immediately states the action. No redundant words or filler sentences are present.

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 simplicity (one parameter, no output schema, straightforward polling logic), the description is complete. It explains what to do, what input to use, and the termination condition. There is no missing information that would hinder an AI agent from correctly using 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 describes the single parameter (handle) with 100% coverage. The description adds context by linking the handle to buy_phone_number, but does not provide additional meaning beyond what the schema offers. Therefore, the description adds minimal value for parameter understanding, resulting in a baseline score of 3.

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 polls for an incoming SMS code using a handle from buy_phone_number, with a specific condition ('Repeat until status is received'). It uses a specific verb ('poll') and resource ('incoming SMS code'), and directly distinguishes itself from the sibling 'buy_phone_number' which purchases the number.

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 usage context: it should be used after buying a phone number via buy_phone_number, and the handle from that purchase is required. It also specifies a polling loop condition ('Repeat until status is received'). However, it does not explicitly mention when not to use it or list alternatives among siblings, though for this simple polling tool that is acceptable.

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 bears the burden of behavioral disclosure. It covers pricing per tier, input/output token caps, error conditions (402/503), payment method (USDC on Base), and return format (assistant reply with finish_reason and token usage). No contradictions or gaps.

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, well-structured paragraph that front-loads the most critical information (no account, no API key, no token math) and includes all necessary details without redundancy. Every sentence earns its place.

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

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

Despite no output schema, the description sufficiently explains the return format. Given the tool's complexity (multiple pricing tiers, input caps, error handling), the description is complete enough for an agent to select and invoke 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?

Schema description coverage is 100%, so baseline is 3. The description adds value beyond schema by explaining pricing tiers in context, combined input character limits per tier, and output token defaults. It also clarifies that thinking tokens are spent first for reasoning tier.

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 'LLM chat completion per call' and distinguishes itself from sibling tools (which are mostly business/check tools) by highlighting unique features like no account needed, flat pricing tiers, and OpenAI-style messages. No confusion about what this 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 provides clear context for when to use this tool (for chat completions without accounts or API keys) and explains pricing and input caps. However, it does not explicitly state when not to use it or mention alternatives, but since no sibling tool offers similar functionality, the guidance is adequate.

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 provided, so description carries full burden. It discloses what data is returned (legal name, status, jurisdiction, etc.), states 'Legal entities only', and implies read-only nature. Could mention rate limits or auth, but acceptable for a lookup 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 key purpose, zero wasted words. Efficiently conveys purpose, usage, and return 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?

For a 3-parameter tool with no output schema, description adequately covers return fields and usage context. Could mention pagination or format details, but not critical.

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%, baseline 3. Description adds value by explaining that 'lei' is a 20-character ISO 17442 code, that either 'lei' or 'name' should be provided, and that 'jurisdiction' is an optional 2-letter country filter.

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 is an LEI lookup from the official GLEIF register, specifies lookup methods (by LEI code or legal name), and lists returned data. It distinguishes itself from sibling tools that are country-specific company checks.

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

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

Explicitly says 'Ideal cheap first check before deeper company screening', providing clear context for when to use. Lacks explicit when-not-to-use or alternatives, but context is sufficient.

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 fully discloses behavioral traits: it is a paid service ($0.004/call) using USDC on Base, no account or API key needed, returns compact JSON with specific fields, allows tuning with parameters, and treats zero results as a valid response. This goes beyond basic function to inform agent decision-making, though rate limits or error behaviors are not 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 three sentences of efficient information: purpose, output format, tuning, pricing, payment, and edge case. Every sentence earns its place with no redundancy, and key details are 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?

Given the tool's simplicity, high schema coverage, and lack of output schema, the description adequately covers input, output, cost, authentication, and a key edge case (zero results). It could mention error handling for invalid parameters, but overall it provides sufficient context for reliable agent 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?

Schema coverage is 100% and each parameter is well-described in the schema (query required, num with default/max/min, country and lang with patterns). The description adds only a summary of the tuning capabilities and the 'plain text' nature of query, which does not substantially extend the schema's information. 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 identifies this as a Google News search tool for AI agents, specifies the source (Serper.dev), and distinguishes it from the related /web/search tool. It explicitly states the input (query) and output format (compact JSON with fields like position, title, url, snippet, publish date, source), leaving no ambiguity about the tool's 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?

The description implies usage for news retrieval and mentions pricing and zero-result validity, but does not explicitly state when to use this tool versus alternatives like web_search or web_images. No direct when-not-to-use guidance or differentiation from sibling tools is provided, though it is the only news-specific tool in the sibling list.

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 provided, so description carries full burden. It states it performs a live probe, checks monitoring history, and provides facts only, indicating a read-only operation. However, it doesn't explicitly state that no state is changed.

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, well-structured, and front-loaded with the core purpose. Every sentence adds value without unnecessary 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?

Given no output schema, the description adequately hints at the return (live probe metrics, monitoring history, facts only). For a simple tool with 2 parameters, it provides sufficient context for use.

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 value by explaining the pay_to parameter is verified against the live 402 and the resource parameter is used for both live probe and monitoring history, going beyond schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs a preflight check before paying an x402 service. It lists specific checks (live probe, 30-day monitoring history, optional pay_to verification) and distinguishes itself from siblings by its focused pre-payment 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 implies use before paying an x402 service, but doesn't explicitly mention when not to use or compare with alternatives like check_x402_counterparty or x402_service_report. Still, 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?

With no annotations provided, the description does a good job: discloses cost ($0.01/call), payment method (USDC on Base), no account/key needed, failure behavior (503, no charge), and that it's relayed live from an upstream source. It lacks mention of rate limits or idempotency, but overall transparent for a simple 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?

Three sentences, each carrying key information: what it does, how to use it, cost/behavior. No fluff, front-loaded with the core purpose. Every sentence earns its place.

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

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

Given no parameters, no output schema, and no annotations, the description covers all needed context: real-time nature, sentiment analysis, ranking, cost, failure mode, auth requirements (none), and output format. It fully equips an agent to understand and invoke 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?

No parameters in the schema, so coverage is 100%. The description adds value beyond the schema by explaining the output format (structured JSON with sentiment, ranked headlines) and the cost model, which is essential for an agent to decide to invoke it.

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 provides 'real-time crypto market news with sentiment analysis and top headlines ranked by importance', specifying the verb (relay/get), resource (crypto news), and distinct features (sentiment, ranking). This distinguishes it from sibling tools like crypto_feed_since or scan_crypto_market.

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

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

Explicitly states it's a one-request, no-parameter call for latest market-moving stories, suitable for trading agents and research pipelines. It also mentions failure mode (503, no charge). While it doesn't explicitly list when not to use or compare to alternatives, the zero-parameter nature and clear purpose make usage obvious.

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 covers source (data.sec.gov), live relay, error behavior (503, pay nothing), payment model (USDC on Base, no account), and return format (company, form type, filing date, URL). Lacks rate limits but sufficient.

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

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

The description is composed of 3-4 concise sentences, front-loaded with the tool's purpose. Each sentence adds unique value: purpose, return details, pricing/error handling. No unnecessary 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?

Given 5 parameters, no output schema, and no annotations, the description covers essential aspects: source, filtering, pricing, error handling, and return fields. Lacks a full output schema description but lists key fields, making it 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 description coverage is 100%, so baseline is 3. The description adds context ('filterable with since and limit', 'provide exactly one of ticker or cik') but does not significantly enhance parameter understanding beyond 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 states the tool retrieves latest SEC EDGAR filings for US-listed companies, listing specific form types (10-K, 10-Q, 8-K) and return fields. This is distinct from sibling tools like relay_crypto_news or web_search.

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 clear context: use by ticker or CIK, filterable with 'since' and 'limit', pricing $0.01 per call, and error handling (503 if source down, no charge). No explicit exclusion or alternative, but no similar tool exists among 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?

Since no annotations are provided, the description fully covers behavioral traits: it returns specific fields, allows sorting and time filtering, mentions pay-per-call cost and pay-in-ins, and explains failure mode (503 with no charge). No contradictions with annotations.

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 action and cost, then efficiently covers parameters, use cases, and failure behavior. While not minimal, every sentence adds value and avoids redundancy.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description is fairly complete. It covers output fields, sorting, time window, pricing, and failure mode. It lacks explicit pagination or rate limit info but is adequate for a search 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 provides 100% coverage of parameters. The description adds extra value by specifying exact match syntax for 'q', clarifying that 'time' applies to 'sort=top', and noting the optional subreddit scope. This goes beyond the schema's baseline.

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 that the tool performs keyword searches on Reddit or specific subreddits, returning specific post fields. It distinguishes itself from siblings like web_search by focusing exclusively on Reddit.

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 use cases (social listening, brand monitoring) and conditions (no login/API key required, pay per call). However, it does not explicitly state when to avoid this tool or compare to siblings like web_search.

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?

Given no annotations, the description fully carries the burden. It discloses that the request is free, not a promise to build, only coverage identifier is aggregated, free-text notes are never resold, and the allowed characters for value. It also explains the note storage and privacy.

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 well-structured with key info front-loaded. It is slightly verbose but each sentence adds value. Could be trimmed slightly, but overall efficient.

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 is very complete. It covers purpose, usage, limitations, privacy, and provides an alternative tool. 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?

Schema description coverage is 100%, but the description adds extra meaning: it clarifies that 'note' is optional, stored but not resold, and provides constraints for 'value' (allowed characters). This adds significant 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?

The description clearly states the tool's purpose: reporting missing coverage (coin, country, host, etc.). It uses specific verbs and resources and distinguishes itself from the sibling file_agent_want, which handles budget requests.

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 when to use this tool (after a rejection from a paid tool) and when not to (for budget requests, use file_agent_want). It also mentions limitations (capped at 20 per caller per day) and free nature.

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?

Without annotations, the description fully discloses behavioral traits: the score is a heuristic not a calibrated probability, no execution/custody/position sizing, paid per request, empty list valid. This is comprehensive and leaves no ambiguity.

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 well-structured with key information front-loaded. Each sentence adds value, though it could be slightly more concise without losing clarity. Overall efficient.

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 presence of output schema, the description is complete: it describes return fields (signal_id, version, coin, classification, etc.), explains the scoring heuristic, notes response naming next call, and covers edge cases like empty list. No 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?

No parameters exist, so as per guidelines baseline is 4. The description does not need to add parameter information since there are none.

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?

Description clearly states the tool returns machine-readable crypto market long opportunities from an upstream advice system, ranked by a heuristic score. It distinguishes from siblings by specifying it's about 'long opportunities' and an 'upstream advice system', which is distinct from tools like check_crypto_signal or get_crypto_signal that focus on individual signals.

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: to obtain a list of current long opportunities. It clarifies what the tool does NOT do (no execution, no custody, no position sizing), which guides against misuse. However, it does not explicitly compare with alternative tools or provide when-not-to-use guidance, hence slightly below perfect.

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 discloses behavior: registers consulted, return type (attention items with source references), charging model (only when both registers used), and scope (companies only).

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 paragraph, front-loaded with purpose, then explains checks, requirements, returns, charging, and scope. No unnecessary words; 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?

Given no output schema, the description explains return type (factual attention items with source) and scope. Could be clearer about the structure of attention items, but sufficient for an agent to understand 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 67%; description adds meaning by explaining why each parameter is needed and providing example format for VAT number. This compensates for the missing schema description on legal_name.

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 performs Dutch supplier screening by validating EU VAT number, checking insolvency register, and cross-checking legal name. It distinguishes from sibling tools like check_dutch_insolvency or verify_eu_vat by combining multiple checks into one call.

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?

Describes the tool as a pre-transaction check in one call and lists required parameters. However, it does not explicitly state when to avoid this tool or compare it to alternatives among the sibling 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?

Despite no annotations, the description fully discloses behavior: normalised name matching across aliases, returns per match (source list, matched names, programmes, designation date, source link, each list's generation date), and limitations (entities only, not a clearance). No contradictions with annotations (none provided).

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?

Single concise paragraph front-loaded with the core action. Every sentence adds value: describes the lists, matching method, return details, and limitations. No redundancy.

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

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

Tool has one parameter and no output schema, so description must fully explain its purpose, processing, and outputs. It does so thoroughly, covering input (company name, entities only), process (normalised matching across both lists), and output details (source, matched names, etc.), plus limitations. Complete for its complexity.

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 only parameter 'name' is described in schema as 'Company/organisation name to screen (entities only, no persons)'. The tool description reinforces this with context about the screening process and the two lists. Schema coverage is 100%, so baseline 3; the description adds extra nuance, earning a 4.

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 screens a company/organisation name against two specific sanctions lists (EU and UN). It distinguishes from siblings like screen_eu_supplier by specifying scope (entities only, no persons) and coverage (two specific lists). This is a specific verb+resource combination.

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

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

Explicitly states 'not_listed is no clearance' and 'other jurisdictions (e.g. OFAC) are not covered', providing clear when-to-use and when-not-to-use guidance. Also contrasts with sibling tools that may cover other jurisdictions.

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 provided, so description must cover behavior. It discloses that the tool is read-only ('factual only – no scores'), explains response structure ('states per dimension what was and was not covered'), and lists data sources. It does not mention authentication or rate limits, but the core transparency 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?

The description is slightly verbose but well-structured: it opens with the tool's purpose, then details routing and coverage. Every sentence provides essential information with 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?

Given no output schema, the description adequately explains what the response contains (per-dimension coverage matrix). It covers all parameters and country-specific details. Minor missing details: no mention of error handling or unlisted countries, but overall complete for the tool's purpose.

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%, but the description adds significant value by explaining how each parameter is used (e.g., name for sanctions, country for routing), listing country-specific registration number formats (KVK, SIREN, etc.), and detailing VAT coverage. This goes beyond the schema's simple 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 clearly states the tool performs European supplier screening, combining multiple official sources per country. It distinguishes from siblings (e.g., check_* single-country tools, screen_eu_sanctions) by offering a comprehensive multi-dimension screening in one call.

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 use for comprehensive screening of suppliers in listed countries, but does not explicitly state when not to use it (e.g., for unlisted countries or single-dimension checks) or recommend alternatives among siblings. Usage context is clear but exclusions are 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 effectively discloses behavioral traits: it performs a live status check, returns extensive real-time data, and explicitly states it is read-only ('no execution, no custody, no position sizing'). It also mentions the service is paid per request.

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 efficiently conveys the purpose and outputs. However, it could be improved by structuring the list of outputs more clearly (e.g., bullet points) and front-loading the most critical 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?

Given the tool's low complexity (one parameter, output schema exists), the description is fairly complete. It explains what the tool returns and its non-execution nature. However, it lacks mention of prerequisites (e.g., how to obtain a valid signal_id) and error handling scenarios.

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 covers 100% of parameters with a detailed description for signal_id. The tool description adds no additional parameter-level information beyond what the schema provides, so 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 clearly identifies the tool's purpose: validating a crypto signal by checking its live status. It specifies the verb 'validate' and the resource 'crypto_signal', and distinguishes from siblings like 'get_crypto_signal' by emphasizing real-time freshness and return of detailed live data.

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 such as 'get_crypto_signal' or 'check_crypto_signal'. The description states 'Advice only: no execution...' but does not provide context for when to choose this tool over others.

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?

Discloses caching behavior, mode differences, requirements for consultation_proof, and caveats like 'not confirmed' not meaning invalid. Also mentions machine-readable errors and per-member-state availability. Without annotations, this provides thorough behavioral insight.

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?

Five sentences cover purpose, modes, caveats, and errors. Front-loaded with key information. Efficient but not overly concise.

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?

Covers main behaviors and parameters. No output schema, but return values are partially described (timestamps, consultation number, machine-readable errors). Adequate for a validation 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 descriptions for vat_number and requester_vat_number provide examples and constraints. Mode parameter missing schema description but explained in tool description. Overall adds meaning beyond 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 states the tool's function: EU VAT number validation against VIES. It specifies verb and resource, and distinguishes it from sibling tools that check company registrations or sanctions.

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?

Describes two modes and when to use each (fast for cached result, consultation_proof for live verification). Does not explicitly compare to sibling tools, but the purpose is self-evident.

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?

Despite no annotations, the description fully discloses behavior: stripping scripts/styles/navigation, output format options, max_chars with truncated flag, handling of unreachable or non-HTML URLs, and payment in USDC without account needed.

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 focused paragraph that front-loads the core purpose. Each sentence adds distinct information, though it could be slightly more concise without losing 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?

Given the tool's simplicity and no output schema, the description is complete: it explains the readable core (title, headings, etc.), output formats, size cap, and cost structure, fully covering what an agent needs to invoke 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%, baseline 3. Description adds value by explaining how formats differ, specifying default max_chars (20000) and the truncated flag, and clarifying URL restrictions (no IP addresses, localhost, non-http schemes).

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 reads web pages and returns clean markdown or plain text. It distinguishes itself from sibling tools like web_search and web_crawl by emphasizing it is the 'natural companion to /web/search' and the cheapest x402 page reader.

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 clear context: send a URL, choose format, cap size, and notes cost ($0.0015) and that unreachable targets cost nothing. Does not explicitly exclude alternatives, but the use case is well-defined.

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 provided, so description carries full burden. It details crawling behavior (breadth-first, same-host), pricing per page, failure handling (skipped pages listed, start page error returns 400), and payment method (USDC on Base). No gaps.

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?

Information-dense and well-structured, but slightly long (multiple sentences). Could be tightened without losing clarity, but front-loaded with core function.

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?

Covers return format (clean markdown per page, skipped array), edge cases (failed pages, unreachable start page), pricing, and payment. No output schema exists, but description adequately explains 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% with descriptions. Description adds significant context: pricing per requested page, that finding fewer pages is still complete delivery, failed pages skipped and listed, start page unreachable is 400 no charge. This meaningfully supplements 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 states the tool crawls one site, starting from a URL, with max_pages, breadth-first, returning each page as markdown. This distinguishes it from siblings like web_contents (single page) or web_search (search results).

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?

Includes pricing, page limits, behavior on failures, and payment method. Could explicitly contrast with alternatives (e.g., web_contents for single pages), but context from sibling names makes it clear enough.

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?

Disclosed pricing ($0.004/call), source (Serper.dev), payment method (USDC on Base, no account/API key needed), and behavior on zero results ('valid, honest answer'). No annotations provided, so the description fully compensates, exceeding typical 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 a single paragraph but is dense and efficient. Every sentence adds value (pricing, source, output format, parameters, zero results). Could be slightly more structured, but it's well within acceptable conciseness.

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, but the description clearly explains the return values (top image results with fields: position, title, image URL, source page link, dimensions). This covers what the agent needs to know. With 4 parameters (1 required), the description is 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 baseline is 3. The description restates parameter tuning (num, country, language) but adds minimal new meaning beyond the schema; noting zero results validity is helpful but doesn't affect parameter semantics significantly.

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 'Google Images search for AI agents', specifying the verb 'search' and resource 'Google Images'. It distinguishes from siblings by mentioning the same source as web_search and the specific image result format.

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 'Send a query, get back compact JSON' and explains parameters for tuning, implying when to use (for image search). It lacks explicit exclusion of alternatives but given sibling names like web_search and web_scholar, the differentiation is clear enough.

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?

Despite no annotations, the description discloses output format, pricing, payment model, and that zero results are valid. It does not mention rate limits but provides sufficient behavioral 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?

Efficient single paragraph, front-loaded with purpose, then output format, options, behavior, and pricing. 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?

No output schema, but description fully explains returned fields and tuning options. Covers pricing and edge case of zero results. Complete for the tool's complexity.

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 description restates parameter uses (num, country, language) without adding new semantics beyond schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Google Places (local businesses with rating, address and phone number)' and contrasts with sibling /web/search, making the specific resource and verb evident.

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 use for local business queries via 'from the same Serper.dev source as /web/search' and mentions tuning parameters, but lacks explicit when-to-use or when-not-to-use compared to siblings.

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

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

No annotations are provided, so description carries full burden. It discloses pricing, payment method, that zero results is valid, and output format. This gives sufficient behavioral insight for an agent.

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?

Four sentences, clear and front-loaded. Every sentence adds value: purpose, pricing, output structure, parameters, expected results, payment. 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?

No output schema, but description explains return fields. Covers source, pricing, payment model. Could mention rate limits or error handling but not necessary for typical usage. Adequate for a search tool with sibling differentiation.

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 already documents all four parameters with descriptions (100% coverage). Description reinforces tuning with num, country, lang but adds no new semantic details beyond what schema provides.

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?

Description explicitly states it performs Google Scholar search for papers with citation counts, and lists the output fields (title, url, publication info, year, citation count). This clearly distinguishes it from general web search or news search 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?

Provides context such as same source as /web/search and mentions zero results indicate no papers. However, it does not explicitly state when to use this tool over siblings like web_search or news_search.

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 burden. It discloses output structure (organic results, direct answer, knowledge graph, related searches), pricing, and that zero results are valid. However, it omits error behavior, rate limits, and whether the tool is read-only.

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 long and front-loaded with the most critical information (pricing and purpose). Every sentence serves a purpose, though the pricing detail could be considered extraneous for selection but relevant for cost-aware agents.

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 adequately explains return values (position, title, url, snippet, etc.) and tuning options. It is fairly complete for a web search tool, though it lacks details on error responses and pagination.

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 value by summarizing parameter usage ('Tune with num...') but does not significantly expand beyond schema descriptions. The extra context is marginal.

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 performs web search for AI agents, specifying output format and distinguishing from siblings like web_images and web_search_read. It uses a specific verb ('search') and describes the resource ('web'), making it easy to differentiate.

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 explains how to tweak parameters (num, country, language) but does not explicitly state when to use this tool vs alternatives like web_search_read. It lacks exclusions or when-not-to-use guidance, leaving the agent without clear decision criteria.

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 provided, so description bears full burden. It discloses pricing ($0.006), error behavior (read_error, call settles), and result structure (position, title, url, snippet, content). Lacks details on rate limits or API source, but adequate for agent decision.

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?

Four sentences, no fluff, front-loaded with key benefit. Could be slightly more structured, but efficient overall.

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 adequately outlines return format (position, title, url, snippet, content) and error case. Completeness is sufficient for a combined search-read 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 covers all 6 parameters with descriptions (100% coverage), so baseline is 3. Description adds context like pricing and error handling but does not provide additional parameter-level detail 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 clearly states the tool combines web search and reading in one call, distinguishing it from siblings like web_search and web_contents. It explicitly mentions 'Search and read in one call' and highlights cost savings.

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?

Describes when to use (when both search and reading are needed), mentions cost benefit over separate calls, and notes error handling for unreadable pages. No explicit when-not, 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?

With no annotations, description fully discloses behavior: 30-day aggregation, data sources, and exclusions (no wallets, free text, subject ids). It clearly defines scope and limitations.

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?

Four concise sentences, each adding value. No unnecessary information; well-structured and 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 an output schema, the description covers purpose, data sources, aggregation period, and scope limitations comprehensively.

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?

Tool has zero parameters, so baseline is 4. No additional parameter semantics needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool aggregates demand data (what agents ask for but cannot buy) over 30 days, from specific sources (rejected calls, free requests, settled intents). It distinguishes itself from sibling tools like x402_network_report by noting 'Demand at one provider, not a network-wide picture.'

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?

Description indicates when to use: for provider-specific demand data, not network-wide. It implicitly suggests alternatives (network report) but does not explicitly state when not to use.

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 provided, so description carries full burden. It discloses that the call is free, takes up to 50 hosts, and returns status, payTo, price, and cursor changes. However, it does not explain error conditions (e.g., invalid feed_handle, unsupported hosts), rate limits, or guarantee of freshness. Adequate but not fully 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?

Two sentences, zero waste. Front-loaded with key qualifier 'Free with a feed_handle' and then succinctly states action and expected output. 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?

No output schema, but description lists returned fields. Complexity is low (simple check). With many sibling tools, this description provides sufficient context for use. Lacks details on error handling or pagination, but acceptable for a one-call utility tool.

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

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

Schema coverage is 100% so parameters are documented. The description adds meaning: 'hosts you are about to pay' clarifies purpose, 'anything that changed since your cursor' elaborates cursor usage, and 'Free with a feed_handle' gives context for feed_handle. Adds value beyond 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 explicitly states the action: 'send up to 50 hosts' and get status, payTo, price, and changes since cursor. It distinguishes from sibling tools like x402_network_feed_since by focusing on checking specific hosts before payment. The verb 'check' is implied and context clarifies 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?

Provides clear context: 'One call before a batch of payments' and 'Free with a feed_handle' indicating when to use and cost. Does not explicitly mention when not to use or alternatives, but the sibling set includes similar tools and the use case is well-defined.

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 provided, so description must disclose behavior. It mentions it's 'free' and lists data types, but doesn't clarify read-only nature, error handling, or auth requirements.

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 with essential info and an instruction. No unnecessary 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?

Adequately describes purpose and basic usage, but lacks output schema and response details. Fair given no output schema.

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 parameters are documented. Description adds context to feed_handle but doesn't enrich other parameters beyond 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 states it returns changed network data since a cursor, listing event types. It mentions a prerequisite (feed_handle from subscribe), but doesn't explicitly distinguish from sibling 'x402_network_feed_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?

Implies usage after subscribing and sending back next_cursor. No explicit when-not or alternatives like feed_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?

With no annotations, the description carries the full burden. It discloses the 30-day duration, probe frequency (~2 per host per day, 1500+ hosts), and that it returns a handle and cursor. However, it does not mention any destructive or read-only nature, nor data volume or rate limits, leaving some gaps.

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 paragraph that front-loads the core purpose and provides necessary details. It is reasonably concise, though could be slightly more structured for ease of parsing.

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 zero parameters, the description sufficiently covers the subscription behavior, return values, and how polling works. It explains the type of data (changes, status, payTo, price) and different endpoints, making it complete for 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?

The tool has zero parameters, so the description adds value by explaining the return values (handle and cursor) and how they are used for polling. Since there are no parameters to document, this 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 explicitly states the tool subscribes for 30 days to a change feed, with specific details about probes and frequency. It distinguishes from sibling tools like x402_network_feed_since and x402_network_feed_check by focusing on the subscription action.

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 explains the subscription's purpose and notes that polling is free and unlimited after subscription, referencing other endpoints. While it doesn't explicitly state when not to use, the sibling tool names provide context for 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?

No annotations provided, so the description carries the full burden. It discloses that the report is regenerated once per day, based on proprietary probes, and contains only facts (no scores), which helps the agent understand the data latency and 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 a single dense sentence but well-structured, front-loading the purpose and then detailing contents. It could be slightly more concise, but every part 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?

Given no parameters and no output schema, the description is very complete. It enumerates all report components: hosts monitored, probe share, host status (ok_402, errors, unreachable), manifest coverage, and various changes over 24h/7d. No missing context for an agent to understand what the tool returns.

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?

There are zero parameters, and schema coverage is 100% (empty schema). The description does not need to explain parameters; baseline for no parameters is 4. It adds no param-specific meaning but is not required.

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 is a 'daily state-of-the-network report' with specific contents like hosts monitored, probe statuses, and changes. It distinguishes itself from siblings like 'x402_service_report' by being network-wide and fact-based.

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 it is for getting an overall network health summary, but it does not explicitly instruct when to use this versus siblings like 'x402_service_report' or 'preflight_x402_service'. No ‘when not to use’ guidance provided.

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 exist, so description carries full burden. It discloses the error condition (400 host_not_monitored, no charge) and explicitly states 'Facts only — no scores', providing good 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?

Description is fairly concise given the richness of the report. It is front-loaded with the core purpose and each sentence adds detail, though could be slightly trimmed.

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 no output schema, the description thoroughly explains what the report includes (probes, uptime, events, payment details) and the error case, making it complete for the tool's complexity.

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, and the description adds value by clarifying that it accepts 'a full URL' beyond hostname, enhancing the parameter's meaning.

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 this tool provides a 'Full reliability report on one x402 service' with specific data points (probes, uptime, events, payment details), distinguishing it from siblings like x402_network_report.

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 this is for factual reliability data ('Facts only — no scores') but does not explicitly guide when to use vs 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.