Factline

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

Beyond the annotations it discloses the payment mechanics (secure link, iDEAL or card, via Dodo Payments, EUR 2.95 incl. VAT) and the delivery behavior (report opens right after payment). This is exactly the behavioral context an agent needs before triggering a paid transaction and is not derivable from the 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?

Front-loads the outcome (payment link) and price, then the report contents, then the usage condition. The enumerated content list is long but each item is informative; structure is sound with little wasted text.

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 explains the return value (a secure payment link) and the post-payment behavior, covering the important gaps. It is nearly complete, though it does not clarify how the free-text q parameter relates to the structured postcode/house_number options.

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 all five address parameters (q, postcode, house_number, addition, house_letter) are already documented in the schema. The description adds only the phrase 'on a Dutch address' and no extra syntax or precedence detail beyond the schema 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 states a specific verb (buy) and resource (the full address report), and itemizes exactly what the paid report contains. It is clearly distinguishable from the free sibling tools like nl_home_report and nl_home_basic.

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?

'Only use when the user wants the full report or asks to buy it' is an explicit usage constraint and exclusion, which is strong. It does not, however, name the specific free alternative tools an agent should route to otherwise, so it stops short of full routing 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?

Annotations already disclose openWorldHint=true and idempotentHint=false; the description adds the crucial business context they do not carry: the EUR 1.95 incl. VAT cost, the payment providers (iDEAL/card via Dodo Payments), and that the payload is a payment link rather than the report itself. It could go further on whether the link is single-use or time-limited, but the concrete financial behavior is well disclosed.

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

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

Two sentences, front-loaded with the return value and cost, then the usage condition. The report-contents enumeration is long but arguably earns its place by telling the agent what the purchase actually delivers.

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

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

With no output schema, the description must explain the return value — and it does, specifying a secure payment link. The single required parameter is fully covered by the schema, so nothing needed to invoke this tool correctly 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% for the single licence_plate parameter, and its format example is already in the schema. The description adds no format, normalization, or validation detail beyond that, so the baseline 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?

States a specific verb and resource — returns a payment link for the full vehicle report — and enumerates the report contents (APK history, defects, recalls, import/taxi/export history, specs). This clearly distinguishes it from the sibling report/spec tools such as nl_vehicle_report and nl_vehicle_basic.

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?

"Only use when the user wants the full report or asks to buy it" gives explicit activation criteria, which matters for a paid tool. It stops short of naming the free/alternative sibling (e.g. nl_vehicle_report) as the fallback when the user does not want to pay.

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?

Beyond the readOnly/idempotent annotations the description discloses pricing (0.03 USDC via x402 or 15 credits), the free tier (first 5 paid calls per day, no key), the verdict vocabulary (pass / review / block_review), and a jurisdiction flag (Xinjiang). These are operational facts an agent cannot infer from annotations or schema.

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

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

The use case is front-loaded in the first clause and every sentence carries non-redundant information (lists, verdict, exclusion, cost). The middle sentence is dense and list-heavy but not padded.

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, yet the description names the verdict values and mentions that reasons accompany them, so the agent knows what comes back. Scope limits, cost, and required-vs-optional input are all covered for what is otherwise a two-parameter tool.

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

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

Schema coverage is 100%, so both parameters are already documented; the description adds that the USCC is 18 characters and that its checksum, registration authority, entity type and province are actually validated, which tells the agent what a malformed code will surface. It does not add anything about the name parameter beyond the schema.

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

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

States a specific verb and resource (check a Chinese supplier's USCC and screen it against named sanctions lists) and enumerates exactly which lists are covered, which lets an agent distinguish it from eu_sanctions_screen, us_trade_screen, eu_company_check and company_lookup without opening any schema.

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

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

"Use before paying or importing from a Chinese supplier" gives an explicit trigger, and "Does not query the Chinese register (GSXT)" explicitly excludes the neighbouring capability an agent might otherwise assume. Both when-to-use and when-not-to-use are stated.

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

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

Annotations already declare read-only, idempotent, non-destructive and open-world, so the description does not need to restate safety. It adds genuinely non-obvious behavior instead: the x402/API-key cost model, the 5-free-calls-per-day allowance, and the output shape ('one verdict and a cite_as line'). It does not cover failure modes (no match, partial register coverage) or latency, which keeps it below a 5.

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 use case and scope are front-loaded, and the cost/input/output clauses are each doing work for a paid, multi-source tool. It is a single dense paragraph of moderate length with some compression (parenthetical country lists) that borders on information dumping but stays readable.

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, and the description compensates by stating the return ('one verdict and a cite_as line') and the sources behind that verdict, along with cost and identifier input. For a zero-required-parameter, open-world paid tool it is close to complete, with only edge-case behavior left unstated.

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 baseline is 3, but the description adds actionable guidance the schema does not: an identifier (name or id) is what is needed and country should be supplied where possible, which matters because the schema marks zero parameters required. It omits the kvk/vat/domain parameters entirely, so it does not fully mirror 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 names a specific resource and enumerates its full scope: registers in 10 countries plus GLEIF, director/owner/parent sanctions and PEP screening, VAT, Peppol, website, plus financial health and insolvency checks in named countries. That enumeration lets an agent distinguish it from narrower siblings such as eu_vat_check, company_health or company_lookup without opening any schema.

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

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

'Use for due diligence before a deal, contract or large payment' gives a clear triggering context, and the payment details tell the agent when a paid call is viable versus free-tier. There is no explicit statement of when not to use it or which narrower sibling to prefer for a single check, so it stops short of a full routing instruction.

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?

Beyond the readOnly/idempotent annotations it discloses pricing and auth paths (0.02 USDC via x402, 10 credits of a Factline key, first 5 calls/day free) and the possible verdict values including limited_data — important since there is no output schema. It omits what happens on unsupported countries or why a result degrades to limited_data, so it stops short of full 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?

Front-loaded usage clause followed by a compact country-by-country signal inventory and a single payment sentence; every clause carries information. The country enumeration is long but each item earns its place by telling the agent what it will get; splitting pricing into its own sentence would improve scanability.

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

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

With no output schema, the description correctly supplies the verdict enum and the signal set per country, plus cost/auth so the agent can decide whether to call it. It could be stronger on partial-data behavior and on how to combine id/name/country, but for a 4-optional-param lookup it is close to complete.

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

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

Schema coverage is 100% so the baseline is 3, but the description adds real meaning: it ties `country` values to signal depth ('GB, FR, NO and FI have full signals; NL with kvk') and explains that a KvK number unlocks the Dutch insolvency register. No guidance on `id` vs `name` precedence, though the schema examples partially cover that.

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

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

States a specific verb+resource ('check if a European company is healthy') and enumerates exactly which signals are returned per country (UK accounts overdue, French BODACC, Norwegian bankruptcy, etc.). The aggregate verdict taxonomy (healthy/watch/distressed/limited_data) separates it from narrower siblings like company_lookup, company_dossier or nl_insolvency_check, which cover only a slice of this.

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?

'Use ... before you deal with it' gives a clear triggering context, and the country list tells the agent which jurisdictions are worth querying. However, no sibling is named as an alternative and there is no explicit when-not (e.g. use company_lookup for a simple identity lookup instead of paying for signals).

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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description earns credit for disclosing the cost model (0.008 USDC via x402 or 4 credits), the x402 payment path, and the free-tier allowance of five paid calls per day — none of which the annotations convey. It doesn't say what a no-match result looks like, which is the main remaining behavioral gap.

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

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

Front-loaded with the use condition, then scope, then outputs, then pricing — the right order for an agent scanning for a decision. The registry enumeration is long but each entry conveys real coverage information, so it mostly earns its place.

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

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

For a read-only lookup with no output schema, the description supplies the return fields, the registry coverage, the lookup keys and the payment semantics. The one meaningful omission is disambiguating this tool from its many siblings and stating the minimum viable input, given that all params are optional.

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 all three parameters documented, so the baseline is 3. The description adds the useful hint that id accepts LEI/SIREN/UK/Irish/Estonian identifiers and ties the registry list to country selection, but it never clarifies the combination rule — notably that zero parameters are required, so an agent could legally call with no arguments.

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?

A specific verb+resource (verify a company exists and is active) with the registries covered, the return fields, and the two lookup keys (name or id) all named. It stops short of distinguishing itself from overlapping siblings such as us_company_lookup, eu_company_check, company_dossier or company_health, so an agent can't tell from the text which one to pick.

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?

"Use when you need to verify that a company exists and is active" is a real trigger condition, which is more than implied usage. But with seven-plus near-neighbour tools in the sibling list, there are no exclusions, no routing rule (e.g. use us_company_lookup for US-only), and no statement of what to do when the register isn't in the covered 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?

With annotations already covering safety (readOnly, idempotent, openWorld), the description adds the traits annotations cannot: cost of 0.003 USDC via x402, a 2-credit alternative via a Factline API key, and a free allowance of the first 5 paid-tool calls per day. It also shows the shape of the result — a low/medium/high risk rating with human-readable flags like 'registered 4 days ago' — which tells the agent what evidence to expect.

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 trigger condition is front-loaded and the paragraph is dense with facts rather than filler. It is a long single sentence-chain, though; splitting the cost/payment sentence from the capability sentence would improve scannability.

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

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

No output schema exists, so the description has to convey the return shape itself, and it does by naming the risk tiers and example flags. Payment prerequisites are stated, which is critical for a paid tool. The response structure beyond the risk label is still sketched only in outline, leaving minor gaps for an agent planning to consume the output.

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

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

Schema coverage is 100% and the single 'domain' parameter is already documented as accepting a domain, URL, or email. The description repeats that accepted input set ('Accepts a domain, URL or email') without adding normalization rules, format constraints, or invalid-input behavior. Baseline 3 applies since the schema does the 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 opens with a specific verb and resource ('judge whether a website or email domain is trustworthy') and then enumerates the exact signals returned — RDAP registration date, expiry, registrar, nameservers, MX/SPF/DMARC, disposable-domain lists, and a graded risk level. That is far more precise than the bare tool name. It doesn't explicitly name a sibling like email_verify to say how it differs, which keeps it below a 5.

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

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

'Use when you need to judge whether a website or email domain is trustworthy' gives a clear triggering condition and scope. It doesn't state exclusions or point to alternatives such as email_verify or company_lookup, so boundary cases are left to inference.

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

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

Annotations only say this is a safe read; the description adds what an agent cannot get from them: the pricing model (0.002 USDC via x402 or 1 Factline API key credit), a free tier of 5 paid-tool calls per day with no key required, and the exact three-way verdict taxonomy. Cost/auth behavior is precisely the kind of disclosure readOnlyHint cannot carry.

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

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

Front-loaded with the usage trigger, then checks, then verdict, then payment terms. Every clause carries decision-relevant information (pricing and free tier matter materially for choosing this paid tool); no filler or repetition of the title.

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, yet the description names the return values (deliverable / risky / undeliverable) and covers the auth/payment prerequisites in full. Nothing an agent needs before invoking a single-parameter paid verification tool is missing.

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

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

One parameter at 100% schema description coverage ('Email address, e.g. jan@example.nl'), so the schema already carries the semantics. The description adds nothing about accepted formats or input edge cases, hitting the baseline for fully documented schemas.

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

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

States a specific verb+resource ('verify an email address') and enumerates exactly what is checked (syntax, MX, disposable domains, role addresses, typo suggestions, SPF/DMARC) plus the single verdict returned. An agent can distinguish it from phone_verify or domain_check without opening the schema.

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

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

Opens with an explicit trigger: 'Use when you need to know if an email address is real and deliverable before signup, outreach or onboarding.' Strong positive guidance, but it names no exclusions or alternative sibling tools (e.g. phone_verify) for adjacent validation needs.

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?

Goes well beyond the annotations by disclosing the commercial terms an agent must know before calling: 0.05 USDC via x402, 25 credits with a Factline API key, and the first 5 paid calls per day free without payment or key. It also reveals the aggregation scope (10 registers plus sanctions/PEP lists) and the four possible verdicts, which annotations alone cannot convey.

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

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

Front-loaded with the usage trigger and the scope list, and every clause carries real information (registers, screening targets, verdicts, input hints, pricing). The single dense run-on sentence packs several ideas together, making it harder to scan than it needs to be, but there is little waste to cut.

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

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

For a zero-required-parameter, no-output-schema aggregation tool this covers purpose, inputs, cost, auth and the top-level verdict vocabulary, which is what an agent needs to decide and call. The gap is that the four verdicts are named but not defined (what makes a result 'review' vs 'incomplete', or what evidence accompanies the verdict), so the return shape stays partly implicit despite the missing 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 the baseline is 3, but the description adds a genuine retrieval hint not in the schema: 'best with country' signals the disambiguation strategy when only a name is supplied. It then names the optional qualifiers (vat, domain, kvk) that sharpen the match, though it adds no format or precedence rules beyond that.

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

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

States a specific verb+resource ('European company check') and enumerates exactly what gets looked up: 10 named registers, sanctions/PEP screening of the company, directors, owners and parents, VAT/Peppol, websites, bankruptcies. This clearly separates it from narrower siblings like eu_vat_check, nl_insolvency_check or eu_sanctions_screen, which do only one of these things.

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?

Opening clause gives concrete triggering situations ('before onboarding, paying or contracting a European company'). It also tells the agent the best input shape ('name or id, best with country'). It stops short of naming alternatives among the 30 siblings — e.g. when to prefer company_lookup, company_dossier or kyc_check — so exclusions are absent.

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?

Goes well beyond the readOnly/openWorld/idempotent annotations: it discloses that this is a live call against a third-party registry, that data may be partial ('when published'), and — critically for a paid tool — the exact cost model (0.003 USDC via x402 or 2 credits) and the free 5-calls-per-day allowance that requires no key. These are the operational facts an agent needs before spending money.

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?

Opens with the trigger condition, then layers data source, result content, scope, and cost in a tight sequence. Every clause carries operational information — no filler or repetition of the title.

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

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

With no output schema, the description correctly compensates by describing the return content (registered/valid flag plus trader name and address when published). Payment and free-tier mechanics are fully covered. Minor gap: it does not say what a not-found or malformed number yields, though 'registered and valid or not' implies a negative result is possible rather than an error.

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

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

Schema coverage is 100% and the schema already documents the single 'eori' parameter with an example (IE6388047V). The description adds only the coverage constraint (EU only, no GB), which is useful scope information but not additional parameter syntax or format guidance. Baseline 3 applies.

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

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

States a specific verb and resource ('check an EU EORI customs number'), names the authoritative data source (European Commission's EORI service), and describes what comes back: registered/valid status plus trader name and address. The resource is clearly distinct from siblings like eu_vat_check or company_lookup, and regional scope plus the explicit 'GB numbers are not covered' exclusion removes ambiguity.

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

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

"Use when you need to check an EU EORI customs number" gives a clear trigger, and the GB exclusion tells the agent when NOT to use it. However, it never names a sibling alternative (e.g. eu_vat_check for VAT numbers), so the agent must infer routing itself.

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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered; the description adds genuinely new operational context: it is free, covers ~30 currencies, supports only today or working days within the last 90 days, and returns cross rates. The working-day/90-day constraint is exactly the kind of limit an agent needs and could not infer from 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?

Front-loaded with the single most decision-relevant token ('Free') followed by the when-to-use clause, then inputs. One dense block with essentially no filler; only slight cost is the packing of constraints into a run-on list.

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

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

With no output schema, the description does enough: it names the data source, coverage, date window and that cross rates come back. It could say more about the response shape or what happens on non-working days, but an agent has what it needs to invoke this 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 0% and all four params are bare strings, so the description carries the full documentation burden. It supplies the default for base (EUR), a format example for symbols (USD,GBP), a format for date (YYYY-MM-DD), and identifies date and amount as optional — a meaningful lift, though it never clarifies that amount is a numeric quantity typed as a string.

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

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

States a specific verb+resource combination: ECB euro reference rates for ~30 currencies, plus cross-rate conversion, with the currency universe and date range named. An agent can distinguish it immediately from every sibling (none of which deal with FX) without opening the schema.

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

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

Gives an explicit trigger — 'Use when the user needs an official euro exchange rate or a conversion for an invoice, contract or report' — which maps a user intent onto the tool. It stops short of stating when not to use it or naming an alternative, but no sibling is a plausible substitute for FX rates.

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?

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the bar is lower. The description adds genuinely useful context beyond them: cost ('Free') and the exact return payload an agent can expect. It does not mention rate limits or auth, but for a free public read it adds value above what the structured fields provide.

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

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

A single dense sentence front-loads the cost/usage cue ('Free. Use when...') and then packs purpose, return fields, and both accepted input formats with no filler. Every clause carries information.

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

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

There is no output schema, so the description carries the burden of describing return values – and it does so explicitly (title, date, in-force status, EUR-Lex link). Combined with the input-format examples and safety annotations, nothing needed to call the tool correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description supplies concrete input examples the schema only restates: a CELEX number (32016R0679) and free-text citations (Directive 2015/849). This clarifies that two different identifier formats are accepted, which is useful disambiguation.

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

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

States a specific verb (lookup) and resource (EU regulation/directive/decision) and enumerates exactly what is returned: official title, date, in-force status, EUR-Lex link. This cleanly distinguishes it from sibling checks like eu_company_check or eu_vat_check, which target different EU identifiers.

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

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

Gives a clear triggering condition ('use when the user cites an EU regulation, directive or decision and you need its official title, date, whether it is still in force, and the EUR-Lex link to cite'), which is strong context. It does not name an alternative tool or state when not to use it, but the sibling set has no overlapping citation-lookup tool, so this is near-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?

Goes well beyond the annotations: discloses fuzzy matching behaviour, the exact response shape (per-name possible-match flag, top score, up to 3 scored matches with their lists), the 25-name cap, and a complete cost model (0.0012 USDC/name, 0.03 USDC or 15 credits, first 5 paid calls free). For a paid tool, pricing and payment prerequisites are the key behavioural facts and they are all here.

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

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

Three sentences, front-loaded with the trigger and scope before pricing details. Every sentence carries information, though the two pricing sentences partially overlap (per-name cost vs. total cost vs. free-tier).

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

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

With no output schema and no annotations describing returns, the description fully specifies what comes back per name and how matches are scored. Batch limits, payment options, and the free tier are all covered, which is everything an agent needs to invoke this paid 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 coverage is 50%: the 'names' parameter is already documented with the ';' separator and example, and the description only reinforces the 25-name cap. The 'type' enum (person/entity) has no description in either the schema or the description, so an agent gets no guidance on when to set 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?

States a specific verb (screening), resource (names of people/companies) and precise scope: up to 25 per call against four named sanctions lists. The batch scope distinguishes it from the single-record eu_sanctions_screen sibling, even though that sibling is not named.

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

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

Opens with an explicit trigger ('Use when screening a list of people or companies at once') and names concrete use cases (customer bases, payouts, vendor lists). It stops short of naming the single-name alternative eu_sanctions_screen for one-off checks, so the boundary is implied rather than stated.

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

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

Beyond the annotations, the description discloses data coverage (25,000+ entities, weekly refresh), fuzzy matching behavior, return contents (scored matches with lists, references and birth dates), and exact payment mechanics including free daily calls. These are substantive behavioral details an agent needs before invoking a paid external lookup.

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 usage trigger and moves efficiently through coverage, matching behavior, return values and cost. Every sentence earns its place and nothing is redundant.

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

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

With no output schema available, the description explains what the tool returns, how matching works, what lists are covered and how payment/free-tier access works. That is sufficient for an agent to 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 coverage is 67%, so the schema already documents the name and birth_year parameters. The description explains fuzzy name matching, but it adds little about the person/entity type parameter or how birth_year disambiguates results, leaving some semantic gaps.

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

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

The description states a specific verb and resource: screening a person or company name against EU, UN, UK and US OFAC sanctions lists. It also clarifies the singular-name scope, implicitly distinguishing it from the batch sibling eu_sanctions_batch.

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

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

It gives a clear trigger: use when you must check whether a person or company is under sanctions. It does not explicitly name alternatives such as us_trade_screen, pep_screen or eu_sanctions_batch, nor does it state when not to use the tool.

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

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

Goes well beyond the annotations by disclosing data provenance (OFAC SDN list), refresh cadence (weekly), the exact response fields (sanctioned, currency, listed entity, programme), and the full cost model including the 5 free calls/day. Annotations already cover safety; the description adds the operational facts an agent needs before calling a paid tool.

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

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

Three tight sentences: usage trigger first, then scope/data source, then return fields and pricing. No redundant restatement of the title, and the payment details are essential for an agent that must decide whether it can afford the call.

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 enumerates the returned fields, and it covers cost, freshness, and supported chains. For a single-parameter read-only lookup, nothing an agent needs to invoke it correctly 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?

Only one parameter with 100% schema description coverage including an example address, so the schema carries the semantics. The description adds useful context about which chains/address formats are accepted but gives no per-parameter syntax or format rules beyond what the schema shows.

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

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

States a specific verb (checks/screens) and a specific resource (crypto wallet addresses) against a named source (US OFAC SDN list), and enumerates supported chains. The wallet/address scope distinguishes it from the name-based siblings like eu_sanctions_screen and pep_screen without ambiguity.

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

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

Gives concrete triggering conditions: 'Use before sending crypto to an address, or when asked if a wallet is sanctioned.' Clear context for invocation, but no explicit when-not guidance or named alternative (e.g. eu_sanctions_batch for many addresses, or the x402_payee_check sibling).

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?

Annotations already declare read-only, idempotent, non-destructive, open-world behavior, so the bar is lower. The description still adds genuinely non-obvious operational context: pricing (0.005 USDC via x402 or 3 API credits) and a free tier of the first 5 paid calls per day. It does not mention result caps or pagination.

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

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

Four tight sentences, front-loaded with the usage trigger, then scope, then the NL extension, then cost. Every sentence carries information an agent needs before calling.

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

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

With no output schema, the description correctly summarizes the return payload (English titles, buyer, deadline, value) and covers payment/auth before the call is made. Missing only edge detail: result limits, pagination, and accepted formats for the value/deadline filters.

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 50%, and the description names the domain meaning of five filters (country, CPV, keywords, deadline, minimum value). However it gives no format guidance for the undescribed parameters (deadline_within, min_value, limit) — e.g. whether deadline_within is days or a date — so it only partially compensates for the coverage gap.

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

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

States a specific verb and resource ('search open public contracts/tenders') plus the authoritative source (TED, plus TenderNed for NL) and the filterable facets. No sibling tool in the list does tender sourcing, so the distinction is immediate.

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

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

Opens with an explicit trigger: 'Use when the user looks for public contracts to bid on.' It also carves out the NL below-threshold case that TED does not cover. It stops short of naming when NOT to use it or pointing to an alternative for non-EU procurement.

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?

Annotations already declare readOnly, idempotent, open-world and non-destructive, and the description still adds substantial context beyond them: pricing (0.003 USDC via x402 or 2 credits of an API key), a free tier of five paid-tool calls per day with no key required, that the check hits the live European Commission VIES service, and that the registered company name and address are returned where shared.

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 front-loaded with the use case first, then the input format, then the cost model. No sentence is filler: the coverage scope, example, and payment terms all change how an agent would call or recommend 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?

For a single-parameter read-only lookup with no output schema, the description covers what the tool returns (validity plus registered name and address when shared), how to format the input, and the payment requirements — everything an agent needs to call it and to warn the user about cost.

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% and there is a single required parameter, so the schema already carries the semantics. The description restates the country-prefix format with the same example ('IE6388047V') that the schema provides, adding no new constraint or validation rule — baseline 3 applies.

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

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

The description names a specific verb and resource ('know if it is valid' for an EU VAT number) and adds scope detail: live VIES lookup covering all 27 member states plus Northern Ireland. It is clearly distinct in kind from generic siblings, though it never explicitly separates itself from the near neighbors eu_eori_check and eu_company_check, which an agent could plausibly confuse for VAT validation.

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?

'Use when the user gives an EU VAT number and you need to know if it is valid' gives a concrete triggering condition an agent can match against. It stops short of naming alternatives or stating when to prefer eu_eori_check or eu_company_check instead, so no exclusion guidance is present.

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?

Annotations already declare non-read-only, non-destructive, open-world behavior, and the description adds genuinely new facts: it's free, the credit allotment, and the one-key-per-email constraint. It does not say what the response contains or what happens on a duplicate request for the same email, which is the remaining gap.

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

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

Three short sentences, front-loaded with cost and trigger, then the constraint. No filler and nothing repeated from the schema.

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

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

With no output schema and no annotations covering return values, the description should ideally hint at what comes back (the key itself, validity window). It conveys the key facts an agent needs to decide to call it, but leaves the response shape implicit.

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 meaningfully reinforces the email parameter (work email, ask the user, never invent one). However, 'name' and 'use_case' carry no description anywhere, and the description does not compensate for them, so the 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?

Names a concrete verb and artifact ('issues a trial API key') and quantifies the grant (2,000 credits a month), which is enough to distinguish it from the paid-check siblings that consume credits rather than create access.

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

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

Gives an explicit trigger ('Use when the user wants to use Factline's paid checks without a crypto wallet') plus an operational rule ('Ask the user for their email first; never invent one'), so the agent knows both when to call and how to prepare the call.

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?

Annotations already declare readOnly/idempotent/openWorld, and the description adds substantial information they cannot carry: the exact cost (0.001 USDC via x402 or 1 Factline credit) and the free-tier rule (first 5 paid calls per day, no payment or key). It also discloses a meaningful limitation, that holding is not verified.

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

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

Three short sentences, front-loaded with the use case, then the scope caveat, then pricing. There is no filler; each sentence carries decision-relevant 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?

For a one-parameter read-only tool, the description covers purpose, limits and payment model well, and effectively tells the agent what results are produced (checks plus Dutch bank). It stops short of describing the response shape, but nothing needed to decide or call the tool is missing.

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

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

There is a single required parameter with 100% schema description coverage including a format example, so the schema does the heavy lifting. The description explains what the IBAN is validated against but adds no syntax or format guidance beyond the schema example.

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

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

States a specific verb and resource ('check an IBAN') and enumerates exactly what the check covers: country length, mod-97 checksum, SEPA membership, and Dutch bank identification. This is clearly distinguishable from siblings such as eu_vat_check, kyc_check or x402_payee_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?

Gives a concrete trigger ('before a payout or invoice') and an explicit scope boundary ('Does not confirm the account holder'), which implicitly routes account-ownership checks elsewhere. It does not name a sibling alternative by name, so it stops short of a 5.

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

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds materially: execution is parallel, the return values are enumerated (pass, review, block_review, incomplete), and payment/auth are spelled out (0.01 USDC via x402 or 5 API credits, first 5 paid calls daily free). Cost and payment mechanics are exactly the kind of behavior annotations cannot express.

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 trigger condition is front-loaded and every sentence carries payload: what is screened, what comes back, what it costs. The second sentence is a long run-on that packs three checks together, which costs a little readability but no information is wasted.

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

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

For an 11-parameter, no-output-schema, paid tool this covers the essentials (verdicts, price, input flexibility) but omits how optional parameters change results, e.g. that kvk adds a bankruptcy check or how the pep flag behaves. An agent can call it, but cannot reason about which optional inputs to supply.

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

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

Schema description coverage is only 45% across 11 parameters, so the description needs to compensate and largely does not. It names name, email, phone and vat, but says nothing about kvk (bankruptcy check), the pep toggle, type, company, country, birth_year or company_country, leaving most of the input surface undocumented in both places.

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

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

States a specific action with its full scope: sanctions screening against EU/UN/UK/US lists plus PEP, email and phone verification, and VIES VAT lookup, collapsed into one verdict. This clearly distinguishes it from the single-purpose siblings (eu_sanctions_screen, pep_screen, email_verify, phone_verify, eu_vat_check) as an aggregate 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?

"Use when onboarding a customer, seller or business and you want one answer" gives a concrete trigger, and "Send any of name, email, phone, vat" tells the agent the minimum input posture (no required params). It does not explicitly name the single-check siblings or say when to prefer them over this aggregate call, so no exclusion 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?

Annotations already declare readOnly, idempotent, openWorld, non-destructive. The description goes beyond them with pricing behavior: 0.0015 USDC per address, 0.015 USDC via x402, 8 credits of a Factline key, first 5 paid calls per day free, and unfound addresses flagged but not charged. It does not cover rate limits beyond the free tier or response shape, which is why this is a 4 rather than a 5.

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

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

Front-loaded with the 'Use when' trigger followed by scope, returned fields, then cost. Pricing is stated three ways (per-address, total, credits, free tier), which is slightly repetitive but each form serves a different agent decision.

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

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

With no output schema, the description carries the return-value burden and does it: it lists exactly what fields come back, describes the partial-failure case (unfound addresses flagged), and explains all payment paths. Nothing an agent needs in order to call this correctly is missing.

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

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

Schema coverage is 100%, so both parameters are already documented. The description adds meaning beyond the schema: the hard 10-address cap, the per-address cost implication, and that the energy label is optional via 'include'. It does not restate the ';' delimiter syntax, which the schema already covers.

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

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

States a specific verb and resource: enrich a list of Dutch addresses, up to 10 per call, and enumerates the returned data (BAG address, coordinates, CBS neighbourhood, liveability, crime, home value, optional energy label). The batch scope of 10 per call implicitly separates it from the single-address siblings like nl_address_lookup and nl_address_reverse, but no sibling is named explicitly.

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

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

"Use when enriching a list of Dutch addresses" is a clear trigger, and the 'include' note tells the agent when to request energy labels. It gives no explicit when-not or pointer to a named alternative (e.g. nl_address_lookup for one address, buy_full_address_report for a deep single report).

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?

Annotations already cover read-only, idempotency and open-world behaviour, and the description adds real context beyond them: pricing (0.002 USDC via x402 or 1 credit), the free tier ('first 5 paid-tool calls a day are free'), and data provenance (Kadaster BAG via PDOK). It does not say what happens when no address matches or when a query is ambiguous, which matters for a geocoder.

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

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

It leads with the trigger condition, then packs the returned fields, use cases, source and cost into compact clauses. Every clause carries either selection value or operational value (cost, free tier), and none is padding.

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

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

With no output schema, it usefully enumerates the returned fields, and it discloses the payment model and authoritative source. Missing pieces are how an unknown or ambiguous address is reported and which sibling to use for bulk or reverse lookups.

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 every parameter already carries an example, so the schema does the heavy lifting. The description's only addition is the framing 'postcode + house number or free text', which restates the 'Alternative to postcode' note already on q.

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

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

The description names the specific verb and resource ('check that a Dutch address exists or get its exact spelling and coordinates') and lists concrete outputs (BAG ids, lat/lon, municipality, province, CBS neighbourhood code). Its input modes (postcode + house number or free text) implicitly separate it from nl_address_reverse and nl_address_batch, but it never names those 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?

'Use when you need to check...' gives an explicit trigger, and the use cases 'onboarding, delivery and CRM' narrow the context. It stops short of exclusions, though: an agent is not told to switch to nl_address_batch for many addresses or to nl_address_reverse when starting from coordinates.

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?

Beyond the annotations, the description discloses the data source (Kadaster BAG via PDOK), the returned fields and distance, and the cost model including the free daily quota and x402/API-key payment options. These are material operational details an agent would otherwise have to discover at call time.

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 use case and input, then compactly lists outputs, source, and cost. Every sentence carries information an invoking agent needs, including the free-tier detail that affects whether payment is required.

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

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

There is no output schema, so the description appropriately enumerates the returned address components and nearby addresses. It also covers input CRS, data source, coverage area, and payment requirements, leaving no major gap for a two-parameter paid lookup.

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

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

The schema already documents both parameters at 100% coverage, so the baseline is 3. The description adds meaningful meaning by specifying WGS84 as the coordinate system, which is not stated in the schema and matters for 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 states a specific verb and resource ('reverse geocode Dutch coordinates' to 'nearest official BAG address') and names the exact outputs. It is clearly distinguishable from siblings like nl_postcode_addresses, which appears to go from postcode to addresses, and nl_address_lookup, which is not coordinate-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?

It gives a clear use condition: coordinates in the Netherlands where an address is needed. It does not explicitly name when to use alternatives such as nl_address_batch for multiple points or nl_postcode_addresses for the reverse direction, so it stops short of full routing 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?

The annotations already declare readOnly, idempotent, openWorld and non-destructive, and the description adds material context: source RDW, cost of 0.001 USDC via x402 or one Factline credit, and five free paid-tool calls per day. That pricing and auth detail matters for an agent deciding whether to call, and the annotations do not contradict it.

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

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

The trigger, output fields, scope, input, source and cost are packed into three sentences, and the trigger leads with no preamble. Every clause carries information an agent needs, including the free-tier detail that affects call decisions.

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

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

There is no output schema, so the description compensates by naming the returned fields and status bands. Together with the source, cost model and free tier, it is complete enough for an agent to call it correctly on the first attempt.

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 only one parameter, and schema coverage is 100% with an example format (GT-722-F). 'Input: Dutch licence plate' restates the schema rather than adding syntax or validation detail, so the baseline of 3 applies.

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

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

The description states a specific verb (look up expiry and validity) and resource (a Dutch car's APK/MOT), and lists the exact outputs: expiry date, days left, status band, insurance and open-recall flags. This clearly separates it from siblings such as nl_vehicle_report and buy_full_vehicle_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 gives an explicit trigger, 'Use when the user asks when a Dutch car's APK expires or whether it is still valid,' and adds that it is cheap enough to run daily for a fleet. It does not name alternatives or say when to use a sibling instead, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: the specific data returned (APK defect rate vs. average, top 10 defects, recalls with component and risk, open-recall share, odometer rollback share, registrations) and the ~450-model coverage scope.

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

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

Front-loads 'Free' and the trigger condition before the dense data enumeration. The long list of returned fields is information-dense rather than padded, though it is packed into a single sprawling sentence.

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

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

With no output schema, the description carries the burden of describing return contents, and it does so thoroughly. For a simple two-parameter lookup tool, an agent has enough to invoke and interpret it correctly.

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

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

Schema description coverage is 100% and both parameters (make, model) are documented in the schema with examples. The description adds no syntax, format, or matching guidance beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb+resource: reliability facts for a car model in the Netherlands sourced from RDW data. The 'Free' prefix implicitly distinguishes it from the paid sibling buy_full_vehicle_report, though it never names that sibling directly.

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

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

Gives explicit trigger conditions ('when the user asks how reliable a car model is, or which used car to buy'), which is clear usage context. It stops short of naming when NOT to use it or pointing to a specific alternative tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description's real contribution is the commercial layer: 0.003 USDC via x402, 2 credits, and the first 5 paid calls per day free with no key. It also names the data provenance (Politie open data, CBS). It stops short of disclosing data recency, error behaviour for unknown postcodes, or rate limits beyond the free tier.

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

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

Front-loads the trigger phrase, then output content, then input, then source and pricing — a sensible order with no filler sentences. The payment sentence is dense and packs three separate cost mechanics into one clause, but each element is genuinely actionable for the caller.

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

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

With no output schema, the description compensates by naming the metrics returned and their form (counts plus ratio), which is enough for an agent to answer a safety question. The remaining gap is the zero-required-parameter design and the unstated behaviour when the postcode falls outside a known buurt.

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

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

Schema coverage is 100% and both properties carry examples, so the description's "Input: Dutch postcode or CBS buurt code" is largely a restatement. Notably, required parameters are 0 and the schema presents these as alternatives without stating exclusivity, and the description doesn't clarify what happens if both or neither are supplied — a gap that affects 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?

States a specific verb+resource (police-registered crime per 1,000 residents vs the national rate) and enumerates the breakdown (burglary, bicycle theft, vehicle crime, violence, vandalism) plus the output shape (counts and a ratio). This clearly separates it from neighbours like nl_neighbourhood or nl_neighbourhood_summary without needing their schemas.

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?

"Use when the user asks whether a Dutch neighbourhood or postcode is safe" gives an explicit trigger condition and input type, which is stronger than most siblings. It does not, however, say when to prefer a sibling such as nl_neighbourhood_summary or what to do if the question is about general liveability rather than crime.

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?

Annotations already cover read-only, idempotent, non-destructive and open-world behaviour, yet the description still adds material context an agent cannot get elsewhere: the RVO EP-Online provenance, the paid nature of the call (0.005 USDC via x402 or 3 API credits), and the free-tier allowance of five paid calls per day. Pricing and auth requirements are exactly the kind of disclosure the description is supposed to carry.

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 tight sentences with a clear front-loaded 'Use when' clause, followed by input, provenance, and cost. Every sentence carries distinct information; nothing is repeated from the title or schema.

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

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

For a read-only lookup with no output schema and all-optional parameters, the description compensates well by describing the returned fields and the 'none registered' fallback, plus the input expectation and cost model. An agent has everything needed to decide and call it correctly.

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

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

Schema coverage is 100%, so every parameter including the free-text 'q' alternative and optional letter/addition fields is already documented. The description only restates 'postcode + house number', adding essentially no semantics beyond the schema, which is the baseline 3 case.

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

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

States a specific verb and resource: retrieves the officially registered energy label of a Dutch home, and enumerates the returned fields (label grade, registration/expiry date, building type, energy index). It does not explicitly differentiate itself from overlapping siblings such as nl_home_basic or nl_home_report, so it falls just short of a 5.

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

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

"Use when the user asks for the energy label of a Dutch home" gives a clear triggering condition, plus the required input (postcode + house number) and the source of truth. It offers no exclusions or named alternatives, so there is no guidance on when to pick nl_home_basic or nl_home_report instead.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), yet the description adds material facts they cannot: the upstream source (Rijkswaterstaat LIWO, AHN), the exact price (0.004 USDC via x402 or 2 credits), and the five-free-calls-per-day waiver. Payment requirements and data provenance are exactly the behavioral context an agent needs before calling a paid tool.

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

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

Three sentences, front-loaded with the trigger condition, then data coverage, then input and cost. Every clause carries information, though the middle sentence is a dense run-on list that could be tightened.

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

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

There is no output schema, so the description must describe returns — and it does, naming every returned metric and its climate scenarios. Combined with input shape, data source and pricing, an agent has everything needed to invoke this 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%, so the baseline is 3. The description goes further by stating 'Input: postcode + house number', which resolves genuine ambiguity — the schema declares zero required parameters and never says which of the five fields form the canonical combination (and that q is an alternative). It still doesn't mention the free-text q path, keeping it below 5.

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

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

States a specific verb and resource ('asks if a Dutch address can flood') and enumerates the exact outputs: annual probability at 20/50/200 cm, 2050/2100 scenarios, worst-case depth, ground height. The Dutch-address + flood-risk scope cleanly separates it from siblings like nl_house_prices or nl_home_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?

'Use when the user asks if a Dutch address can flood' gives a crisp activation condition, and the cost/free-tier note helps the agent decide whether to invoke it now. It does not name a sibling alternative or state when NOT to use it, so it stops short of a 5.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered; the description adds value beyond them by disclosing the data sources (BAG, CBS, Leefbaarometer), the language of results (English), and the cost profile ('Free'). It does not describe failure behavior for unknown addresses, which keeps it at 4.

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 'Free.' and then the trigger, then inputs, then sources. Every clause carries distinct information and nothing is repeated from the schema or annotations.

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

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

With no output schema, the description must convey what comes back, and it does so by listing the fact categories and result language. Sources are cited for provenance. Minor gaps remain on pagination/not-found behavior, but for a read-only lookup it is close to 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 per-field descriptions, so the baseline is 3. The description adds the non-obvious either/or semantics ('Accepts postcode + house number or free text'), clarifying that q and the postcode fields are alternative input modes rather than a combined requirement.

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

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

The description names the resource (Dutch address/home facts) and enumerates the concrete data points returned: year built, floor area, use, neighbourhood residents, average home value, liveability percentile. 'Free' and the 'basic' name implicitly separate it from paid siblings like buy_full_address_report and nl_home_report, but no sibling is named explicitly.

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

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

It gives a clear trigger ('Use when the user mentions a Dutch address or asks about a home in the Netherlands') and notes the free tier, which is the main selection axis against paid siblings. There are no explicit exclusions or named alternatives, so it stops short of a 5.

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

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

Goes well beyond the annotations by disclosing the pricing model (0.08 USDC via x402 or 40 credits of a Factline API key) and the free tier of five paid calls per day, which is exactly the kind of precondition an agent must know before invoking. It also describes the return content (best address per metric plus a full per-address report).

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

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

Front-loaded with the triggering condition, followed by scope, output, input format and cost in a compact sequence. Only the short repeating input line is slightly redundant, and it costs a few words.

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

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

For a one-parameter, read-only tool with no output schema, the description covers the trigger, the address-count bounds, the metrics returned, and the payment preconditions. Nothing material needed to call it correctly 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% and the single parameter already documents the ';'-separated 2-to-5-address format with an example. The description's "Input: addresses separated by ';'" merely repeats the schema, so baseline 3 applies.

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

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

States a specific verb (compare) and a tightly bounded resource (2 to 5 Dutch addresses), then enumerates the metrics compared and the output shape. An agent can tell it apart from single-address siblings like nl_address_lookup, though no sibling is named explicitly.

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

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

"Use when the user is choosing between 2 to 5 Dutch addresses" gives a clear selection condition that naturally excludes single-lookup and bulk-list tools. It stops short of naming an alternative or stating when-not to use it.

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

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

Annotations only declare read-only/idempotent/open-world; the description goes well beyond them by disclosing the exact price (0.04 USDC via x402 or 20 credits of a Factline API key), the free quota (first 5 paid-tool calls a day, no payment or key needed), and the upstream data sources (Kadaster, CBS, Politie, RIVM, RVO). For a paid tool, cost and auth are the highest-value behavioral facts an agent needs before invoking.

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

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

It is a single dense paragraph with the trigger front-loaded and zero filler sentences; every clause (content list, inputs, sources, price) earns its place. It would scan better if split into trigger / contents / cost lines, which is the only reason it is not a 5.

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

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

With no output schema, the description substitutes by enumerating the report sections returned, and it covers inputs, sources, and payment paths. Given five mostly-optional parameters and non-trivial billing, an agent has everything it needs to decide and call correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description only restates the primary input combination ("postcode + house number") and never mentions the free-text 'q' alternative, the optional addition/house_letter fields, or the zero-required-parameters property, so it adds little 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 opens with a specific trigger ("Use when the user asks about a specific Dutch home or address before renting, buying or moving") and then enumerates exactly what the report contains, which makes it distinguishable from narrower siblings such as nl_home_basic, nl_crime, nl_energy_label or nl_neighbourhood: this is the aggregate report. Both the action and its scope are 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 "use when... before renting, buying or moving" framing gives a clear situational trigger and the input requirement (postcode + house number) tells the agent what it needs before calling. It does not name any alternative or exclusion, however, and with siblings like buy_full_address_report and nl_home_basic in the family, an explicit "use X instead when..." statement is the missing piece.

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?

Annotations already cover readOnly/idempotent/openWorld, and the description goes well beyond them: it discloses x402 pricing (0.003 USDC), the API-key credit alternative, a free daily quota, and the data sources (CBS, Kadaster). It also flags the differing aggregation levels (neighbourhood WOZ vs municipal sale prices), which is exactly the kind of trait that prevents misreading results.

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?

Sentences are front-loaded: trigger first, then what is returned, then scope caveat, inputs, sources, and cost. Dense but every sentence carries information; the payment sentence is slightly packed with two mechanisms (USDC and API credits) plus a free tier.

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

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

With no output schema, the description carries the burden of explaining returns, and it does: WOZ with trend, yearly municipal sale prices benchmarked nationally. Missing only minor practicalities such as units/currency or the time granularity of the WOZ trend.

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

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

Schema coverage is 100% and both parameters are already described with examples, so the description adds nothing except restating 'postcode or CBS buurt code'. It does not clarify that both parameters are optional in the schema but that one is effectively needed, which is the one genuinely useful thing it could have added.

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?

Opens with a concrete trigger and resource: average WOZ in the neighbourhood plus average sale prices per municipality vs national. It also draws a boundary ('Context for an asking price, not a valuation of one home'), which separates it from valuation-oriented siblings like nl_home_report. It never names a sibling, so differentiation is implied rather than explicit.

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

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

'Use when the user asks what homes cost in a Dutch area' gives a clear activation condition, and 'not a valuation of one home' provides an explicit exclusion. What's missing is routing guidance toward alternatives (nl_home_basic, nl_rent_check) when the user actually wants a single property or rent.

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?

Goes well beyond the readOnly/idempotent/openWorld annotations: it discloses the live registry queried, that both active and ended cases are covered, the fields returned (court, case number, dates, administrator, claims deadline), the entity-type restriction, and the exact cost/payment mechanics including x402 pricing, credit cost, and five free daily calls.

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

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

Front-loaded with the use case, then inputs, then pricing; a single dense block with no filler sentences. It is somewhat long and the pricing clause is heavy, but every sentence carries decision-relevant 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?

No output schema exists, and the description compensates by enumerating the returned fields. Combined with payment details, entity restrictions, and input options, an agent has everything needed to decide and invoke.

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 two parameters are already documented, but the description adds that KvK or name are alternatives ('Input: KvK number or company name') and that neither is required, clarifying an ambiguity the schema (required: 0) leaves open.

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

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

States a specific verb and resource ('know if a Dutch company is bankrupt or in suspension of payments') and names the authoritative source (Centraal Insolventieregister, Rechtspraak). This clearly distinguishes it from generic siblings like company_health, company_lookup, or eu_company_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?

Explicit trigger context ('Use when you need to know if...') plus an exclusion ('Legal entities only') and accepted inputs. It does not point to any alternative tool when the entity is not Dutch or not a legal entity, so routing against the many sibling check tools is left to inference.

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

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

On top of the annotations, the description discloses the full cost model (0.01 USDC via x402, or 5 Factline credits, first 5 paid calls per day free with no key), the underlying data sources (CBS, Politie, Leefbaarometer), and the response language (English). Cost and auth behavior is exactly the context annotations cannot convey, so this earns the top score.

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

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

A single dense paragraph that front-loads the trigger condition and payload list before the practical details (inputs, sources, cost). Nothing is clearly redundant, though the pricing tail makes it longer than strictly needed for tool selection.

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

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

With no output schema, the description compensates well by enumerating the returned data categories and the language of the result. What is missing is the failure mode when neither postcode nor code is supplied (both parameters are optional) and the response shape.

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% and both parameters carry their own examples, so the baseline is 3. The description's "Input: any postcode or CBS buurt code" adds only the mutual-alternative framing, not format or precedence rules for when both are supplied.

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

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

The description names a specific resource (Dutch neighbourhood / postcode profile) and enumerates the exact content returned: residents and age mix, housing values, income, energy use, amenity distances, crime vs national rate, liveability. That is far beyond a restatement of the name. It does not explicitly differentiate from the close sibling nl_neighbourhood_summary, which keeps it from a 5.

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

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

"Use when the user asks what a Dutch neighbourhood or postcode area is like" gives a concrete trigger condition, and the accepted inputs (any postcode or CBS buurt code) are stated. No alternative sibling is named or excluded, so routing between this and nl_neighbourhood_summary or nl_postcode_addresses is left to inference.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-structured context: the tool is free, it aggregates from three named public sources, and it returns comparative figures (crime vs national rate, liveability percentile) rather than raw data. It does not discuss latency, coverage gaps, or what happens for an unknown postcode, which keeps it below a 5.

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

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

Front-loaded with the two pieces an agent needs first ('Free. Use when...') followed by one dense but well-ordered sentence listing the payload fields and sources. No filler sentences, though the enumerated output list runs long and could be tightened.

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

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

There is no output schema, so the description must carry the return-value burden, and it does: it enumerates each headline metric and names the upstream sources. Combined with annotations covering read semantics, an agent has everything needed to call this correctly and describe the result to a user.

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 both parameters (postcode and optional CBS buurt code) are already documented with examples in the schema. The description only implies postcode-based input ('headline facts for a postcode') and adds nothing about the alternate code parameter, so the baseline 3 for high-coverage schemas applies.

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

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

States a specific resource (Dutch neighbourhood/postcode summary) and enumerates the exact headline facts returned: residents, WOZ home value, owner-occupied share, liveability percentile, crime per 1,000 vs national, and distances to amenities. The 'Free' marker and explicit data sources (CBS, Politie, Leefbaarometer) let an agent place it against siblings like nl_home_report and nl_crime without opening any schema.

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

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

Gives a clear triggering condition: 'Use when the user asks what a Dutch neighbourhood or postcode area is like, or whether it is safe.' That is a strong when-to-use signal, but it names no alternative tool for adjacent needs (e.g. street-level lookups via nl_address_lookup or a single-topic nl_crime query), so the routing is implied rather than explicit.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive behavior, but the description adds critical non-schema context: the Kadaster BAG/PDOK source, the exact cost (0.005 USDC via x402 or 3 credits), and the free-tier rule (first 5 paid calls daily). For a paid data tool, this is exactly the behavioral information an agent needs before invoking it.

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

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

Three sentences, front-loaded with the when-to-use clause, followed by field inventory, use cases, and the payment/source facts. Every sentence earns its place, and nothing is repeated from annotations or schema.

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

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

With no output schema, the description correctly enumerates the key returned fields and sorting. It also covers source, cost, and free-tier access, which are essential for a paid open-world read tool. An agent has everything needed to decide to call it and to anticipate the response shape.

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%, and the single postcode parameter is already documented in the schema with format guidance ('6-character postcode, e.g. 2517AS'). The description adds only the word 'Dutch' and no syntax or normalization detail beyond the schema, 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 states a specific verb and resource — 'every address in a Dutch postcode' — and enumerates the returned fields (street, house number, letter, addition, BAG id, coordinates, sorted). This is far more concrete than the title alone, though it never names the sibling tools it should be preferred over (e.g., nl_address_lookup or nl_address_reverse).

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

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

It gives explicit usage conditions ('Use when you need every address in a Dutch postcode') and concrete scenarios (address pickers, delivery and canvassing routes, data cleaning). It does not state when not to use it or name the alternative for a single address, so sibling routing still requires inference.

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

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

Annotations already declare this as a read-only, idempotent, non-destructive, open-world tool. The description adds important context beyond that: it is a paid call costing 0.01 USDC via x402 or 5 credits of a Factline API key, with the first five paid-tool calls per day free. It also notes the estimate links to the official check, though it does not describe latency or accuracy limits.

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

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

The description is front-loaded with the usage trigger and output summary, followed by input shape, pricing and free-tier details. Every sentence carries useful information, although the pricing sentence is somewhat dense and could be split for easier scanning.

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

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

There is no output schema, but the description explains what the caller gets back: estimated rent points, likely segment under the 143/144-186/187+ thresholds, approximate maximum basic rent for 2026, and a link to the official check. Combined with the access-cost information, this is nearly complete for deciding to call it; only precision caveats and the alternative free-text input path are 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%, so all five parameters are already documented. The description says 'Input: postcode + house number', which conveys the primary input path but omits the free-text 'q' alternative and the optional addition/house_letter fields present in the schema. Baseline 3 is appropriate because the schema does the parameter-level work.

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

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

The description states a specific verb and resource: estimated rent points (WWS) for a Dutch home, derived from floor area, energy label and neighbourhood WOZ. It clearly distinguishes itself from neighbouring address and energy-label tools by naming the WWS points, segment bands and 2026 maximum basic rent outputs.

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

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

It gives an explicit trigger: 'Use when a tenant asks if their Dutch rent is too high or what the maximum rent is'. It does not name a sibling tool to use instead for related questions (for example nl_energy_label for the underlying label), but the intended scenario is unambiguous.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new context: it is free, and it names the upstream sources (DUO, Landelijk Register Kinderopvang), which tells the agent about data provenance and authority. No auth or rate-limit detail, but little is needed for a free read-only lookup.

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

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

Front-loaded with "Free. Use when..." so the eligibility and trigger come first. The subsequent clause is a long enumeration of returned fields, which is dense but each item (distance, denomination, pass rates, places) earns its place given there is no output schema.

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

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

With no output schema and a single required parameter, the description carries the burden of describing returns and does so exhaustively: school levels, per-school metrics, exam pass rates per track, plus childcare types and registered places. An agent knows exactly what it will get back.

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% and the schema itself documents the postcode format with examples (3511LX or 3511). The description adds no syntax or filtering semantics beyond that, so the baseline of 3 applies.

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

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

States a specific resource (primary/secondary schools, daycare, after-school care) tied to a specific input (Dutch postcode/address), and the school/childcare focus clearly separates it from siblings like nl_crime, nl_energy_label, or nl_house_prices.

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?

"Use when the user asks about schools near a Dutch address or postcode, or is moving with children" gives explicit trigger conditions. It does not name any alternative tool or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely useful context beyond that: the lookup is free of charge and the data source is RDW, plus the breadth of returned attributes including a risk level. It does not mention rate limits or auth, but that bar is low given the 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?

A single sentence, front-loaded with the 'Free.' qualifier and the trigger condition before the long but load-bearing field list. Nothing is redundant, though the enumerated return fields make it slightly dense.

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

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

For a single-parameter read-only tool with no output schema, the description compensates by listing what the response contains (APK expiry, insurance, recall, risk level) and naming the data source. An agent has enough to invoke and interpret it; only the sibling-routing detail for the paid reports is left implicit.

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?

One parameter at 100% schema description coverage, with the schema itself supplying the format example (GT-722-F). The description adds no syntax, format or normalization guidance beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific resource (Dutch licence plate / a specific car in the Netherlands) and enumerates exactly what it returns: make, model, age, fuel, Euro class, APK expiry, insurance, open recall, odometer verdict, risk level. The leading 'Free.' implicitly separates it from the paid siblings (nl_vehicle_report, buy_full_vehicle_report), though it never names them.

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

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

Gives a clear trigger condition: 'Use when the user gives a Dutch licence plate or asks about a specific car in the Netherlands.' No explicit when-not or named alternative, but 'Free.' signals the paid-report siblings without spelling out the choice.

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

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

Annotations already cover read-only and idempotency, and the description adds substantive context beyond them: the RDW data source, the paid model (0.004 USDC via x402 or 2 credits), and the free tier (first 5 paid calls per day). It also discloses the comparison-specific output traits (best per metric, red flags) that no structured field carries.

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

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

Front-loaded with the 'Use when' trigger, followed by output, input, source, and cost in a tight single paragraph with no filler. The long metric enumeration is justified because no output schema exists, though it is denser than strictly needed.

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 one parameter fully described, no output schema, and annotations covering safety, the description fills the remaining gaps: return contents, data source, and payment/credential requirements. An agent has everything needed to call it and set user expectations about cost.

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

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

Schema coverage is 100% and the schema itself documents the semicolon-separated plate format with an example. The description only restates 'Input: Dutch licence plates' plus the 2-3 count already implied by the concept, adding no syntax or format 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?

States a specific verb and scope ('choosing between 2 or 3 Dutch used cars') and enumerates the compared metrics, so an agent knows exactly what comes back. It does not name any sibling (e.g. nl_vehicle_report for a single car), so differentiation from the other vehicle tools is left to inference.

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?

'Use when the user is choosing between 2 or 3 Dutch used cars' is a clear, concrete trigger condition. There is no explicit when-not guidance or named alternative for single-vehicle lookups, which the sibling set makes a real gap.

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?

Beyond the annotations, the description discloses important behavior: the data source is RDW, output is in English, the tool costs 0.02 USDC via x402 or 10 Factline credits, and the first five paid-tool calls per day are free. These details are exactly the kind of payment and access context an agent needs before invoking a paid read-only tool.

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

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

The description is front-loaded with the usage condition and report contents, then ends with practical payment information. It is dense but not wasteful; every sentence supports selection or invocation.

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

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

For a one-parameter, read-only, open-world paid tool with no output schema, the description covers the report contents, language, source, and payment model. It gives the agent enough context to call the tool correctly without needing additional output-format explanation.

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

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

Schema coverage is 100% and the single parameter is already documented with an example. The description only repeats that the input is a Dutch licence plate, so it adds no meaningful semantics beyond the schema 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 this is a paid Dutch vehicle report tool for a specific car or licence plate and enumerates the report contents (APK, inspection history, recalls, odometer, etc.). It is specific and useful, but it does not explicitly distinguish itself from close siblings such as buy_full_vehicle_report or nl_vehicle_basic.

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

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

It gives a clear usage context: when the user asks about a specific Dutch car or licence plate, especially before buying used. It does not state when not to use it or name 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?

Adds substantial context beyond the annotations: per-name pricing (0.0012 USDC), total cost, the API-key credit alternative, and the free-first-5-calls-per-day tier. The only omission is overflow behavior when more than 25 names are supplied (error vs. truncation), which matters for a paid batch call.

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

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

Three sentences, front-loaded with the use case before cost details, and no filler. The pricing appears twice (per-name rate and total), which is mildly redundant but internally consistent and useful for cost estimation.

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

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

For a read-only, idempotent, single-parameter batch tool with full schema coverage and no output schema, the description covers purpose, cost, and returned fields adequately. The main remaining gap is what happens at the 25-name boundary and whether partial results are returned for failed names.

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 separator format (';') is documented in the schema itself. The description contributes the one thing the schema omits: the hard cap of 25 names per call, which directly constrains how the parameter must be built.

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

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

States a specific verb and resource ('screen ... names for politically exposed persons') with an explicit batch scope ('up to 25 names in one call'), which implicitly distinguishes it from the single-name sibling pep_screen. It also previews the returned data ('top 3 possible matches per name with positions and status'), so an agent knows both what it does and what it yields.

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

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

Gives a clear when-to-use trigger ('screening a list of up to 25 names', 'customer-base and CRM re-screening'). It stops short of naming the alternative for single-name or larger-list cases (pep_screen, chunking), so the exclusionary half of the guidance is missing.

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

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

Annotations already declare readOnly, idempotent and non-destructive, and the description adds substantial context beyond them: pricing (0.003 USDC via x402 or 2 credits), a free tier of the first 5 paid-tool calls per day with no key needed, the returned data shape, and the regulatory deadlines driving the lookup. Auth and cost information is exactly what an agent needs before calling a paid tool.

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

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

Front-loaded with the trigger, then a single dense sentence covering lookup inputs, outputs, regulatory context and pricing. Efficient overall, though the pricing/regulatory tail could be split for faster scanning.

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

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

No output schema exists, and the description does explain the return contents (participant ids, accepted document types), plus cost and free-tier mechanics. The remaining gap is the zero-required-parameter schema: the description never states that a name, VAT, id or country must be supplied, which could let an agent attempt an empty lookup.

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 description is at baseline. It lists the same identifier schemes (KBO, SIREN, KvK, Peppol id) already present in the schema descriptions, adding no selector logic such as which identifier takes precedence when several are supplied, or the fact that at least one of vat/id/name must be provided despite zero required parameters.

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

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

States a specific verb and resource (looks up a company in the Peppol Directory) and names the concrete outcome (participant ids and accepted document types). An agent can immediately distinguish it from siblings like eu_vat_check or company_lookup, which validate identity rather than e-invoicing reachability.

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

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

Opens with an explicit trigger: 'Use when you need to send an e-invoice or check if a company can receive one.' That gives clear context but names no alternative or exclusion, e.g., whether to use eu_vat_check first to validate the VAT number before attempting the Peppol lookup.

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?

Annotations already cover safety (readOnly, idempotent, openWorld), and the description adds substantive context beyond them: fuzzy matching behavior, the default 5-year recency window for former PEPs, and the full payment model (0.005 USDC via x402, 3 API credits, first 5 paid calls free). For a paid tool, the pricing disclosure is exactly the kind of pre-call information an agent needs.

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

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

Front-loads the trigger clause, then scope, then matching behavior, then cost. No sentence is filler; even the pricing and free-tier details earn their place because they change whether an agent should call this 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?

No output schema exists, and the description does not say what a result looks like (match/no-match, confidence, matched positions or dates), which is a real gap for a screening tool where the agent must interpret the response. Everything else an agent needs to decide and invoke correctly is present.

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 examples for name, country and birth_year, so the schema carries the documentation burden. The description adds one useful hint — 'fuzzy matching with positions, country and dates' — but does not explain how country or birth_year influence matching. Baseline 3 applies.

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

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

States a specific verb and resource ('check whether a person is a politically exposed person') and then enumerates the exact PEP categories and country scope covered, which no sibling name conveys. An agent can tell this apart from eu_sanctions_screen, pep_batch and kyc_check without opening any schema.

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

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

Leads with an explicit trigger ('Use when you must check whether a person is a PEP for AML/KYC') and notes it pairs with sanctions screening, giving clear context. It never names the closest sibling (pep_batch) or states a when-not condition, so it stops short of full routing 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds the traits that actually matter for this paid tool: exact cost (0.003 USDC via x402 or 2 credits), the x402/API-key auth paths, and the first-5-calls-per-day free tier. It does not cover error behavior or latency, keeping it below 5.

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

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

Three sentences, front-loaded with the use case, then the input rule, then the cost. Every sentence carries information an agent needs before invoking a paid tool; nothing is padded.

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?

Only two parameters with full schema coverage, no nested objects, and no output schema needed since the description itself enumerates the returned fields. Payment, auth, and free-tier context fill the remaining gap, so an agent can decide and invoke without further information.

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, but the description adds genuine meaning: national-format input requires the country parameter, with a concrete example pairing 0612345678 with country=NL. That disambiguates a real input pitfall the schema alone leaves implicit.

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

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

States a specific verb ('check') and resource, then enumerates exactly what is returned: validity/possibility against allocated ranges, E.164 and national format, country, line type, and an SMS-capable hint. Distinguished from sibling verifiers like email_verify or iban_check by naming the phone-specific output set.

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?

'Use when you need to check a phone number from any country' gives a clear triggering context, and 'National numbers need a country' gives the prerequisite for the main ambiguity. No explicit when-not or named alternative (e.g., vs email_verify) is offered, so it falls short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive; the description adds what they cannot: the enumeration of checks performed, the outcome taxonomy (no_hits, review, block_review), list-version stamping, and a signed receipt artifact. It also discloses the unusual behavioral traits an agent must plan around: the 0.02 USDC x402 charge, the 10-credit API-key path, and the 5-free-calls-per-day allowance.

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

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

Front-loaded with the triggering use case, then checks, then return values, then input list, then cost — a sensible priority order with no filler. The second sentence is a long run-on covering three separate screens, which costs some readability against an otherwise dense, waste-free phrasing.

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

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

With no output schema, the description carries the return burden and does so by naming the three outcome values plus the accompanying list versions and signed receipt. Pricing, payment rails and the free-tier allowance are also covered. The remaining gap is field-level semantics for the three undocumented optional parameters.

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

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

Schema description coverage is only 20% (only owner is annotated), so the description does useful work by enumerating wallet, owner, owner_type, birth_year and country and marking all but the first two optional. However it never explains formats or constraints for the undocumented fields — wallet address syntax, birth_year format, or whether country is ISO-2/ISO-3 — so it only partly compensates for the coverage gap.

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

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

States a specific verb chain and resource: screens a self-hosted wallet against OFAC-listed addresses, screens the claimed owner against EU/UN/UK/US sanctions and PEP, and checks the company register, then issues an evidence record. It situates itself in a concrete compliance workflow (EU AMLR, Travel Rule) and names its outputs (no_hits/review/block_review, signed receipt), which separates it from generic siblings like eu_sanctions_wallet or pep_screen.

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?

"Use when a crypto service sends to or receives from a self-hosted wallet and must document its checks" gives a clear triggering condition tied to a workflow and jurisdiction. It lacks explicit exclusion guidance or direct naming of the alternative sibling (e.g. eu_sanctions_wallet for a plain screen without the evidence record), so routing is clear but not fully disambiguated.

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?

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), yet the description adds genuinely non-structured behavior: the three-level verdict (pass/review/hold), the fact that a mismatched IBAN against known_iban triggers a hold, and the cost/payment mechanics (0.08 USDC via x402, 40 credits, first 5 paid calls per day free). It stops short of saying how much evidence accompanies a verdict or how long a call takes.

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 invocation trigger is front-loaded and the semicolon-separated check list packs a lot of substance into a few lines with no filler. It is dense to the point of being a fragment run-on, which costs some readability, but no clause is redundant.

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

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

For a 9-parameter, zero-required screening tool with no output schema, the description covers the key unknowns: what is checked, what a verdict means at a coarse level, and the commercial terms. What it leaves out is the shape of the returned evidence (per-check results, reasons for a review/hold) which an agent would need to interpret output without an 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 the baseline is 3, but the description earns more by mapping parameters to checks that are not obvious from the schema: kvk implies the bankruptcy check, IBAN implies valid/same-country/Polish-whitelist checks, email implies sender-email verification, and known_iban implies the changed-bank-details hold. It still does not explain which parameters are needed to reach a verdict versus merely enrich 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 states a specific verb and resource ('Check a supplier invoice before paying') and then enumerates exactly what is bundled: register lookup, sanctions/PEP screening, VAT match, IBAN validity and whitelist, sender email, Dutch bankruptcy, Peppol. That composite scope is what separates it from single-purpose siblings like eu_sanctions_screen, eu_vat_check or iban_check, so an agent can distinguish it without opening the schema.

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

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

'Use before an agent pays a supplier invoice' is an explicit and actionable trigger, and the known_iban note tells the agent when that parameter changes the outcome. However, no sibling is named as an alternative or complement for narrower needs (e.g. when only a sanctions screen is required), so routing depends on the agent inferring overlap from the check 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?

Beyond the readOnly/idempotent/openWorld annotations, the description discloses the critical behavioral facts: a cost of 0.01 USDC via x402 or 5 credits of an API key, and a free tier of the first 5 paid-tool calls per day with no payment or key. It also discloses the coverage boundary (no private companies), which prevents wasted paid calls.

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

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

A single dense paragraph that is front-loaded with purpose, then constraints, then inputs, then pricing. Every clause carries information an agent needs — coverage limits, input modes, cost model, and free tier — 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?

Because there is no output schema, the description properly enumerates what the record contains (legal name, former names, tickers/exchanges, EIN, incorporation state, industry code, address, latest 10-K/20-F and 10-Q dates), and payment mechanics are fully covered. The gap is that with zero required parameters, the description never says an identifier must be supplied, leaving a plausible zero-argument invocation unaddressed.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds the meaningful routing detail that name, ticker or CIK are alternative inputs ("or"), and gives the same examples the schema does. It stops short of stating that at least one identifier is required, which matters because required parameters is 0.

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

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

States a specific verb (verify/find) and resource (US listed company or SEC registrant in EDGAR), and enumerates the record fields returned. The explicit scoping note that private US companies are not in EDGAR separates it cleanly from general lookup siblings such as company_lookup and the region-specific eu_company_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?

"Use to verify a US listed company or SEC registrant" gives a clear when-to-use, and "Private US companies are not in EDGAR" supplies an explicit when-not. It does not name a specific sibling alternative for private-company cases, so routing relies on the agent inferring from 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds context those annotations cannot: the exact cost (0.005 USDC via x402 or 3 credits), the first-5-calls-free allowance, and the crucial semantic point that these lists restrict trade rather than freeze assets. That is exactly the value-add the description should supply.

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 usage instruction and the list scope are front-loaded, and the payment details are compressed into two short sentences with no filler. It is dense but every sentence carries operational information; only the phrase about the sanctions screen is slightly indirect.

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

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

There is no output schema, so the description should explain what a screening call returns (hit/no-hit, matched list, score vs. threshold) — it does not. Combined with the phantom 'threshold' parameter, the definition leaves an agent unsure how to interpret results even though cost and list scope are well covered.

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

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

The description says 'Input: name, optional type (entity or person), threshold' — but the schema has no threshold parameter at all, which will mislead an agent into supplying a non-existent argument. The type enum is present in the schema but left unexplained in both description and schema, and the meaning of a match score is never clarified.

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

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

States a specific verb+resource: screens a name against the US Consolidated Screening List and the DHS UFLPA Entity List, naming the contributing agencies (Commerce, State, Treasury). It also carves itself out from the sanctions sibling by declaring the SDN list is excluded and noting these are trade restrictions, not asset freezes — an agent can distinguish it from eu_sanctions_screen and pep_screen without opening schemas.

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

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

Gives a clear triggering context: 'Use before buying from, selling to or shipping to a company, above all a Chinese or Russian one.' It also implicitly routes SDN-list checks to the sanctions screen. It stops short of naming that sibling tool or stating explicit exclusions (e.g. individuals vs. entities, non-US 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?

Beyond the annotations (which already declare read-only, idempotent, non-destructive), the description discloses how results are delivered (webhook plus /v1/watch/alerts with a returned token), that no account is required, and the billing model (0.05 USDC via x402, 25 credits, first 5 paid calls free). Those operational details are exactly what an agent needs and are not in any structured field.

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 usage trigger is front-loaded in the first clause and the kinds and pricing follow in a dense but well-ordered sequence. It is somewhat run-on, mixing operational and billing facts into a single block, but nearly every sentence carries information an agent needs.

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 output schema, the description explains what the caller receives (a token used to read alerts at /v1/watch/alerts and the alert delivery path) and how to pay. All four parameters, the watch duration, and the alert channel are covered, leaving nothing essential unstated.

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 only 50%, so the description must compensate; it does, by explaining each enum value of kind (sanctions re-screened on EU/UN/UK/US list changes, company with COUNTRY:name, apk Dutch plate) and restating the value formats. The optional label parameter is not described, which is the one remaining gap.

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

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

The description states a specific action (watches one item for 30 days, recurring re-screening) with a clear resource, and enumerates the three watch kinds with their trigger conditions. This distinguishes it from the sibling one-shot screening tools (eu_sanctions_screen, pep_screen, company_lookup) without needing to open the schema.

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

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

"Use for ongoing monitoring: the user wants to be told later or must show screening keeps running" gives a concrete selection trigger that separates it from one-off screening siblings. It stops short of naming an explicit alternative to use instead for a single check, so it is clear context rather than a full when/when-not routing rule.

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?

Annotations already cover the read-only/idempotent/non-destructive profile, and the description adds materially more: the price (0.01 USDC or 5 credits), the free tier (first 5 paid-tool calls per day, no key needed), and the return shape (allow/review/deny plus a trust-provider block with decision, score, evidence, ttl). These are exactly the non-obvious traits an agent needs before invoking a paid tool.

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

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

The trigger condition is front-loaded and every clause carries content (checks performed, return values, pricing). It is dense rather than padded, though the long comma-spliced sentences slow scanning slightly.

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

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

With no output schema and no required parameters, the description does the heavy lifting well: it explains the verdict vocabulary, the evidence block, and the payment model. Small gaps remain around passing only a url vs. also a wallet, and what happens when a check cannot be completed.

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 75%, so baseline is 3. The description does add some meaning – 'with company, the register record and EU/UN/UK/US sanctions' tells the agent that supplying company unlocks extra checks – but 'country' is left entirely unexplained in both schema and description, and nothing clarifies how url vs. wallet interact.

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

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

States a concrete verb and resource ('reads the seller's own 402 challenge', 'screens every payTo wallet against the OFAC list') and enumerates the composite checks performed. An agent can tell this differs from single-purpose siblings such as domain_check or eu_sanctions_wallet without opening any schema.

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

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

Explicit trigger condition: 'Use before an agent pays an x402 endpoint it has not used before'. That is clear when-to-use guidance, but it never names an alternative (x402_pay_guard, x402_sellers, domain_check) or says when to skip this tool.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, and the description adds substantial context on top: it is free, it produces allow/review/deny with reasons plus a signed verdict, and strict mode converts a wallet mismatch or missing pay_to into a deny rather than a review. That is exactly the pre-payment behavioral detail an agent needs.

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

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

Front-loads the key facts ('Free. Use right before paying') then the checks and inputs, with no filler. The body is a long dense sentence, but every clause contributes distinct information, so it remains efficient rather than bloated.

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 6 params and no output schema, the description covers purpose, when to call, the exact checks, the input list, and the return shape (allow/review/deny with reasons and a signed verdict). An agent has everything needed to call and interpret it.

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

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

With 100% schema coverage the baseline is 3, but the description adds meaning beyond the schema: it explains that pay_to comes from the 402 challenge, which fields are optional, and precisely what strict mode does ('deny instead of review on a wallet mismatch or missing pay_to'). That semantic gloss raises it above 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?

States a specific verb and resource ('screens the payTo wallet', 'checks that payTo is a wallet this seller lists') and enumerates the exact checks performed. However, it never names or differentiates from the very similar sibling x402_payee_check, so an agent must infer the distinction rather than being told.

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?

'Use right before paying an x402 seller' gives a clear placement in the workflow, and the mode description implies a stricter usage variant. It stops short of naming alternatives (x402_payee_check) or when not to call it, so it is clear context without 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?

Annotations cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the bar is lower. The description adds genuine value beyond them: data provenance (Coinbase x402 Bazaar), ranking basis (unique payers, 30 days), and freshness via a daily endpoint-validity check. No pagination, rate-limit, or caching behavior is disclosed.

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

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

Front-loads "Free." then the usage trigger, then the payload description. Information-dense with no filler, though the second clause is a dense run-on packing ranking, uptime, speed and networks into one colon chain.

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

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

No output schema exists, so the description carries the return-value burden and does so by describing ranked sellers with uptime, speed, and network data. Adequate for a 3-param read-only tool, though it omits the default/paging behavior of limit and the exact returned fields.

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

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

Schema coverage is 67%, with q and network already documented in the schema; the description only reinforces q with examples ("sanctions, weather, search") that largely duplicate the schema's own example. The limit parameter is undocumented in both schema and description, and its string type for a count is unexplained.

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

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

The description names the specific resource (sellers from the Coinbase x402 Bazaar) and its scope (ranked by unique payers over 30 days, with Factline uptime/speed/network checks). An agent can tell this is a discovery/directory tool, but it never explicitly contrasts itself with the x402_payee_check or x402_pay_guard 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?

"Use when looking for an x402 API to pay for a task, or to see if a seller is used and up" gives an explicit when-to-use trigger. No when-not condition and no named alternatives are provided, but the usage context is clear.

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