SiteCheck Company Records

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

Adds substantial behavior beyond annotations: up to 100 results, closest-first ordering, ADA-members-only coverage limits, a $0.01 USDC cost per successful call, x402 payment methods, and failed calls not charged. These are important operational details an agent could not infer from readOnlyHint/openWorldHint alone.

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 resource and scope, then adds coverage caveats and pricing. It is dense but efficient; the long field enumeration is useful, though slightly bulky.

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

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

Given the output schema, annotations, and 100% parameter coverage, the description supplies the remaining operational context: source, coverage limits, ordering, result cap, and payment behavior. Nothing critical for correct invocation 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 every parameter is documented in the input schema, including limit, address reliability, and specialty examples. The description reinforces ZIP-code usage but adds little 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?

States a specific resource and scope: American Dental Association member dentists near a US ZIP code, with the exact returned fields and closest-first ordering. It distinguishes itself from generic provider directories by emphasizing ADA members only.

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

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

Provides clear context that this is for ADA member dentists near a US ZIP code, and notes members-only coverage, but does not explicitly compare against siblings like WebMD, Healthline, Doximity, or Google Maps. The when-to-use case is implied rather than spelled out.

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=true and openWorldHint=true. Beyond that, the description adds critical decision-relevant behavior: source page type (angi.com companylist via residential proxy) and per-call pricing ($0.002 USDC, x402 on Base/Solana/Arc, failed calls not charged). This cost/success-billing detail is genuinely useful and not in 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 resource and scope, then lists returned fields and closes with source and pricing. The field enumeration is dense but each clause maps to real outputs; not bloated for a data-heavy scraper, though the long field list could be trimmed given the output schema exists.

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, open-world scraper with an output schema and annotations, the description is complete: it covers source, scope, cost, and content. The output schema already handles return-value detail, so the heavy field listing is somewhat redundant, but nothing an agent needs 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% and the schema already documents city/state/service with examples. The description reinforces the domain ('US city', service slug) but adds no syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb+resource: 'Angi (Angie's List) top-rated pros for a service in a US city'. This clearly distinguishes it from generic directory siblings like b2b_yellowpages, b2b_manta, and b2b_bbb by naming the Angi source and the specific scoping (service + US city).

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 context ('top-rated pros for a service in a US city') implies when to use it, but there's no explicit when-not or comparison against alternative contractor-directory siblings such as b2b_clutch_reviews, b2b_goodfirms_companies, or b2b_yellowpages. Usage must be inferred.

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 open-world behavior, and the description adds important pricing context: $0.002 per successful call via x402, with failed calls free. This is valuable and not in annotations, though it could go further on payment flow or rate limits.

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

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

Front-loaded purpose and useful pricing note, but slight redundancy between 'APIs.guru open directory of public API descriptions' and 'Open-source catalogue of published specs'. The field list is somewhat redundant given the 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?

For a simple read-only lookup with full schema descriptions, an output schema, and annotations, the description covers purpose, scope, cost, and payment method. Nothing an agent needs in order 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 coverage is 100%, so the schema fully documents both parameters. The description's mention of domain examples mirrors the schema and adds no extra meaning beyond 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?

Specific verb+resource: 'finds API providers by domain name and returns each of their APIs with [fields]', plus a clear contrast to sibling directories ('not a list of companies'). An agent can immediately distinguish this from company/people directories.

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

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

Provides clear context with domain examples and explicitly states the scope is 'not a list of companies', implying when to reach for this vs company-focused siblings. However, it does not name a specific alternative tool or state explicit exclusion conditions beyond that scope clarification.

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/openWorld annotations, the description discloses cost and payment mechanics ($0.002 USDC per successful call via x402 on Base, Solana or Arc), that failed calls are free, that only public listings are covered, and a licensing constraint on resale. These are exactly the operational facts an agent cannot infer from schema or 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 core capability and return fields, then scope limits, then pricing. It is tight overall, though the pricing/payment clause is dense and slightly crowds out more useful query-syntax guidance.

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?

An output schema exists, yet the description still gives a compact field summary, and it adds the cost, scope, and legal caveats an agent needs before calling. Nothing essential for correct invocation 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%, with both 'q' (2–60 chars) and 'limit' (1–15, default 10) fully documented in the schema. The description only restates that lookup is by business name and adds nothing on input formatting or the effect of limit, 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 and resource — 'Better Business Bureau search (bbb.org public search JSON): finds businesses by name' — and enumerates the returned attributes (city, state, category, BBB rating, membership flag, profile URL). The named source domain plus the explicit 'no complaint details' boundary clearly separates it from siblings like b2b_trustpilot_reviews or b2b_yellowpages.

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?

'Public listings only; no complaint details' tells the agent when this source is not the right one (e.g., for reviews or complaints), which is a genuine routing signal. It stops short of naming the alternative tool to use 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?

Beyond readOnlyHint/openWorldHint it discloses ordering ('newest first'), coverage limits (announced completed deals only, live mandates absent), and a paid-call model: $0.002 USDC via x402 on Base, Solana or Arc with failed calls not charged. That billing and failure-charging detail is exactly the context an agent cannot 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 resource and payload, with no filler sentences. The single long colon-plus-semicolon construction is dense but every clause carries information an agent needs, so it is only slightly less scannable than an ideal version.

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?

Output schema handles return shape, and the description still previews the fields; payment mechanics, ordering, and coverage caveats are all present. For a two-optional-parameter read tool, nothing an agent needs before calling is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning by naming what the keyword matches against (company, country, sector) and confirming the newest-first ordering. It does not restate the limit bounds, which the schema already carries.

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 ('Recent M&A deals closed by Benchmark International') and then enumerates the exact payload (target, acquirer, deal summary, announcement link). No sibling in the list covers M&A deal flow, so the tool is unambiguous against the directory/registry tools around it.

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

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

Gives an explicit inclusion/exclusion rule: 'Only announced completed transactions; confidential live mandates are not public,' and describes the optional keyword filter with its matching dimensions. It does not name an alternative tool or state when a different source would be better, which keeps it 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 and openWorld, but the description adds genuinely useful non-structured context: financials beyond the search page are excluded, and pricing is $0.002 USDC per successful call via x402 with failed calls free. The per-call cost and charge-on-success rule are exactly the kind of behavioral detail annotations can't 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?

Content is front-loaded with what the tool returns, followed by exclusions and pricing. Dense but every sentence carries information; only the pricing sentence is slightly tangential to selection but still relevant.

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

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

With an output schema present and annotations covering safety, the description need not explain return shapes, and it correctly focuses on scope, exclusions, and cost. An agent has enough to decide and invoke correctly; only explicit usage routing to alternatives 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% with both parameters already documented (limit 1-50, default 20; state name format), so the baseline is 3. The description adds no syntax or semantics beyond what the schema provides.

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

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

The description names a specific resource (businesses for sale on BizQuest) and enumerates the returned fields (title, description, asking price, location, image, URL), so an agent knows exactly what it retrieves. It also scopes the source (public search pages, all listings or a US state). It doesn't explicitly differentiate from a sibling marketplace tool, but none in the list is a close competitor.

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?

Scoping is implied by 'all listings, or a US state', and the caveat that off-page financials are excluded hints at when the tool is insufficient. However, there is no explicit when-to-use/when-not guidance or reference to an alternative tool for deeper financial data.

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/openWorld annotations it discloses paid-call mechanics ($0.002 USDC per successful call via x402 on Base/Solana/Arc) and, importantly, that failed calls are not charged — a material detail for an agent deciding to invoke. It also adds data provenance and refresh cadence (free weekly bulk files) and coverage boundaries, which the 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?

Front-loaded with the identity of the record and its source, then the field list, then the pricing caveat. The field enumeration is long but each item is a distinct output field an agent may need; only minor tightening is possible.

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

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

For a single-parameter lookup with an output schema and readOnly/openWorld annotations, the description supplies everything else that matters: data source, update cadence, population size, exclusion of sole traders, and the billing model including no charge on failure.

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 already specifies 10 digits with an example. The description restates the identifier name and digit count but adds no further syntax normalization or format rules, 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: a Swedish company register record looked up by 10-digit organisation number, sourced from Bolagsverket/SCB. It enumerates the returned fields and scopes coverage (2.2M companies/associations, sole traders excluded), which clearly separates it from the many other national company-register siblings such as b2b_brreg_norway_companies or b2b_ireland_cro_companies.

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

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

The lookup key (10-digit organisationsnummer) and the exclusion of sole traders give a clear usage context and one negative constraint. It does not explicitly route the agent away from sibling registers for other jurisdictions, but the country and identifier format make the intended use 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 only declare readOnlyHint and openWorldHint; the description adds substantial behavioral detail beyond that: it caps results at the first 20 of Booksy's own search page plus a total count, and it discloses the metered cost ($0.002 USDC per successful call via x402, failed calls not charged) including accepted payment chains. Cost and result-cap semantics are exactly the kind of context 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?

Three dense sentences that front-load 'what you get' before constraints and pricing. Every clause carries information, though the field enumeration in sentence one is long and could be trimmed slightly. No filler or restatement 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?

An output schema exists, so return shapes need not be explained, yet the description still summarizes the payload, states the result cap and total count, explains region scoping, and discloses pricing and payment mechanics. For a read-only, 3-parameter, paid search tool this covers everything an agent needs to decide and invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it explains that regionId is the number appearing in a Booksy search URL (with concrete examples already in the schema) and that omitting it widens to US-wide, and it reinforces the 20-result limit. Meaningful marginal value over the schema without re-dumping the category enum.

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: businesses listed on Booksy (US) for a category and region, and enumerates exactly what fields come back (address, coordinates, rating, socials, Booksy Pay, promoted flag, services with price/duration). This is clearly distinguishable from the other directory siblings such as b2b_yellowpages or b2b_google_maps because it names the source and the niche vertical.

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

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

It implies usage through constraints: category is required and regionId narrows the search, with 'without it the search is US-wide'. But it never says when to prefer this over the many other local-business directories in the sibling list, nor does it state exclusions or preconditions. Adequate but leaves routing to inference.

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

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

Annotations already establish that it is read-only and open-world. The description adds important behavioral context beyond annotations: public open data, no API key, paid access via x402, and that failed calls are not charged.

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

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

The purpose and returned fields are front-loaded in the first sentence, while the second covers access/payment details. There is no wasted text, and every sentence earns its place.

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

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

For a two-parameter lookup tool with an output schema, annotations, and full schema coverage, the description is complete enough. It covers the data source, return fields, access conditions, and payment behavior.

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

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

Schema description coverage is 100%, and both parameters are documented in the schema itself. The description mentions name-based search but does not add parameter-specific guidance beyond what the schema already provides, 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?

It states a specific verb and resource: searching companies in the Norway Business Register via Brønnøysund. The country-specific framing clearly distinguishes it from sibling country registries such as Sweden, Finland, or Ireland.

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

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

Usage is implied by 'searches companies by name' in the Norway register, and the public/no-key note helps context. However, it does not explicitly say when to choose this over sibling company-registry tools or note any exclusions.

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

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

Annotations already cover read-safety (readOnlyHint) and open-world data, and the description adds genuinely non-inferable context: data provenance (official Census bulk state file), vintage ('latest year published'), legal-form scope ('all legal forms'), the hard limitation of no company-level records, and the exact billing model ($0.002 USDC per successful call via x402 on Base/Solana/Arc, failed calls free). The paid-call and non-refund semantics are the kind of thing an agent must know 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?

What the tool returns is front-loaded, followed by the scope caveat and then pricing, so an agent can stop reading early if the aggregate-only constraint disqualifies it. The single long sentence-chain is dense but each clause (vintage, legal forms, no names, price) carries distinct decision-relevant information; only the payment-rail enumeration (Base/Solana/Arc) is marginal detail.

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?

An output schema exists, so return-value shape need not be described, and with only two fully documented parameters the description covers everything else an agent needs: dataset identity, aggregation grain, data vintage, the 'no company names' limitation, and cost/settlement mechanics. Nothing material is left to inference before a call.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it clarifies that omitting the NAICS code returns all industries and that the code ranges from 2 to 6 digits, and it reinforces that `state` is a FIPS code rather than a name or abbreviation. It does not add format validation or example values beyond what the schema already supplies.

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 dataset (US Census County Business Patterns), the geographic grain (by state FIPS), the metrics returned (establishments, paid employees, Q1 and annual payroll), and the industry grain (all industries or one 2-6 digit NAICS). It also explicitly differentiates from company-level siblings with 'Aggregate counts only, no company names,' which is exactly the axis an agent needs to pick between this and the many company-profile tools listed.

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 'aggregate counts only, no company names' clause effectively states when this tool is the wrong choice (any request for named companies), and the NAICS/state framing makes the intended query shape clear. It stops short of naming a specific alternative sibling (e.g. a company registry tool) for the named-company case, 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?

Beyond the readOnlyHint/openWorldHint annotations, it discloses the data source (Socrata open data), what is excluded from rows, and the full pricing model: $0.002 USDC per successful call via x402 across three chains, with failed calls not charged. The billing and non-charging failure behavior is exactly the kind of context annotations 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?

Three sentences, each earning its place: capability + return fields first, data-scope caveat second, payment terms third. Zero filler and the core purpose is front-loaded.

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

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

With an output schema present, the description needn't describe return values, and it still names the key returned fields. Annotations cover safety, and the description covers source, scope, cost, and failure billing — everything needed to decide and invoke correctly.

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

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

Schema coverage is 100%, so both q and limit are already fully documented in the schema. The description's 'searches by legal or trade name' mirrors the q parameter description without adding syntax or format detail beyond it, 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 ('searches by legal or trade name'), resource ('City of Chicago current active business licenses'), and enumerates the returned fields. The 'current active' scoping plus the Chicago jurisdiction lets an agent distinguish it from sibling registries like b2b_nyc_business_licenses or b2b_texas_sos_business without opening the schema.

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

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

The description establishes clear context — jurisdiction, 'current active' only, and an explicit limitation that it returns 'licence rows only, no ownership or credit data' — which effectively steers ownership/credit queries elsewhere. It stops short of naming a specific alternative sibling, so it earns a 4 rather than a 5.

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

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

Annotations only declare readOnly and openWorld; the description adds substantial context beyond that: data source (clio.com/app-directory), residential proxy, and bluntly states the cost model ($0.01 USDC per successful call via x402 on Base/Solana/Arc, failed calls free). That payment detail is critical and impossible to get from structured fields.

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

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

A single dense paragraph, but it is front-loaded with the resource and field list before the operational details. Every clause (fields, source, pricing) carries weight, though it could be broken into sentences for 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?

Even though an output schema exists, the description fully covers source, pagination, returned fields, and pricing. Nothing an agent needs to decide to call or how to interpret cost 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% (page range 1-60 with default), so baseline is 3, but the description adds genuinely new meaning by specifying one page of 9 items and that a total page count is returned, which clarifies pagination behavior beyond the raw 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 resource (Clio App Directory), enumerates the exact fields returned (slug, name, description, price, logo, link, page count), and frames it as a one-page-of-9 listing. An agent knows precisely what it fetches and it is clearly distinct from the many company/registry siblings.

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

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

The data scope implies usage but there is no explicit when/when-not guidance or reference to alternatives. For a niche-specific directory with no real sibling overlaps this is tolerable, but the agent is left to infer that this tool is only for Clio integration data.

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/openWorld annotations, it discloses a rendering residential proxy, a page ceiling of 10 and ~80 results per page, and precise cost terms ($0.02 USDC per successful call via x402, failed calls free). These are material operational facts an agent cannot infer from structured fields.

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

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

Content is front-loaded with the resource and its fields before pricing, and every clause carries information. The single semicolon-dense sentence is slightly heavy but wastes little.

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

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

With an output schema present, return values needn't be explained, yet the definition adds proxy, pagination ceiling, and billing terms. 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?

Schema coverage is 100%, so the baseline is 3; the description adds value by restating category examples and pinning pagination to pages 1-10 with ~80 results each, giving the 'page' parameter concrete meaning. It does not add syntax detail beyond the schema, so it doesn't reach 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 resource (Clutch.co top B2B service providers in a category) and enumerates the returned fields, so an agent knows exactly what data this yields. It is distinguishable from siblings like goodfirms_companies or g2_software_categories by naming its source directory and category-path model.

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

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

Usage context is clear: pull ranked providers within a category such as web-developers or it-services, with page-based pagination. It lacks explicit when-not-to-use guidance or direct routing to sibling directories (goodfirms, g2), so it stops short of full alternative handling.

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 readOnlyHint and openWorldHint annotations, the description discloses the returned fields, that county-level results add bond and workers' compensation insurer data, that results are paged, and that pricing is $0.002 in USDC per successful x402 call with no charge for failures. These are material behavioral details for invoking a paid public-records 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 source, scope, and returned fields, then moves to filtering, paging, and pricing. It is information-dense and mostly earns its length, though the long field enumeration and run-on structure make it slightly harder to scan.

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

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

For a paid external-registry lookup with five parameters and an output schema, the description covers the data source, required classification scope, county/city filtering, paging, returned fields, and pricing. It is largely complete, with only minor room for additional operational context such as rate limits or error specifics beyond failed-call billing.

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 all parameters are already documented with examples and limits. The description reinforces classification and optional county use and mentions city filtering and paging, but adds little parameter-level meaning beyond the schema, 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?

The description names a specific resource and source: California licensed contractors from the CSLB public Data Portal. It also scopes the result to one classification and optionally one county, making it distinguishable from generic business-license and other-state directories in the sibling list.

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

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

The description implies usage through 'for one license classification' and 'optionally one county,' and notes city filtering and paging. However, it does not explicitly compare this tool with sibling alternatives or state when-not to use it, leaving routing mostly 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 cover read-only and open-world nature; the description adds genuinely new behavioral facts: per-call cost of $0.002 USDC via x402 on Base/Solana/Arc, and that failed calls are not charged — important for an agent deciding whether to retry. It also states paging order, though 'newest index first by relevance' is internally ambiguous.

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 resource and purpose, no filler. Slight deduction because the second sentence stacks paging, ordering, pricing, and payment rails into one dense clause, and the ordering phrase ('newest index first by relevance') reads as two conflicting sort modes.

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

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

With an output schema present, return-field enumeration is somewhat redundant, but the description still supplies the pricing/payment behavior that no structured field covers. The only real gap is the ambiguous sort-order phrasing, which could mislead an agent reasoning about result order.

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% (page, limit with 1–50 range and default 20, query with examples), so the schema already carries parameter meaning. The description adds only the generic 'Paged' hint and does not clarify the units or interaction of page/limit beyond what the schema says.

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

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

Names a specific verb and resource — keyword search over peer-reviewed open access books from the Directory of Open Access Books — and enumerates what each result contains (title, authors/editors, date, abstract, DOAB link with handle, total match count). The resource is unique among siblings (all directories/registries/leaderboards), so an agent can route to it without comparing 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?

The 'keyword search' framing plus 'Paged' and the example keywords imply the use case, but there is no explicit statement of when to prefer this over other book/directory tools or what queries are out of scope. Usage is inferable 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 readOnlyHint/openWorldHint annotations, the description discloses the paid-call economics ($0.002 USDC per successful call via x402 on Base, Solana or Arc, failed calls not charged), the page size (50) and cursor mechanics, and the caveat that some fields appear only 'when listed'. That is exactly the operational context annotations 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?

Three sentences, each front-loading its point: source and modes first, field inventory second, cost and pagination last. No filler, and the pricing/charging caveat is stated compactly rather than 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?

For a zero-required-param, three-parameter lookup with an output schema, the description covers everything an agent needs before calling: which mode each parameter triggers, what a page contains, how to continue pagination, what happens with missing fields, and what the call costs. Return-value structure is correctly left to the 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 already 100%, so the schema documents all three parameters, but the description still adds meaning: it pairs `profile` with the two accepted slug/URL forms, `location` with the state/city slug format plus a worked example, and ties `after` to the returned next-page cursor. That is modest added value on top of a fully documented 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 scope: US clinician data from Doximity's public directory, then splits it into two concrete retrieval modes (single profile vs. location listing) with the exact fields each returns. It never explicitly contrasts itself with neighboring clinician directories like b2b_webmd_healthcare_provider_directory or b2b_healthline_medical_providers_directory, so an agent must infer the distinction from the source name.

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

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

Usage is clearly implied by the input shape: 'By profile (slug or doximity.com/pub URL)' versus 'By location (state or state/city, e.g. north-carolina/raleigh)', which tells the agent which mode each parameter selects. It stops short of explicit when-not guidance, such as what to do if a clinician is not in the directory or why to pick this over a sibling provider directory.

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 readOnlyHint and openWorldHint annotations, the description discloses important behavior: data is from the last trading day rather than real-time, and each successful call costs $0.002 in USDC via x402, with failed calls not charged. These are material operational details for an agent.

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

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

The description is front-loaded with purpose, source, scope, and return fields, then adds only material details about data freshness and payment. Every clause contributes useful selection or invocation context.

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

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

Given the annotations, full schema coverage, and an output schema, the description provides enough context for correct selection and invocation. It also covers freshness and pricing, which are the key non-schema concerns for this paid read-only data tool.

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

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

Schema description coverage is 100%, so the schema already fully documents q, mic, and limit. The description reinforces the MIC-code semantics with examples, but adds little beyond the schema for the other parameters, making the baseline 3 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: lists or searches Euronext listed equities on one market by MIC code. It also identifies the source, return fields, and data timing, making it clearly distinguishable from the NYSE listings sibling.

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

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

It gives clear usage context by specifying one Euronext market via MIC code and noting that data is end-of-day, not real-time. It does not explicitly name alternatives or say 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?

Beyond the read-only/open-world annotations, it discloses that the data is public open data, that financial/credit information is excluded, the exact per-call price, payment rails, and that failed calls are not charged. These are material behavioral details 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 description is front-loaded with what the tool does, followed by scope limitations and pricing. It is compact and every sentence adds useful 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?

With only two parameters, full schema coverage, annotations, and an output schema, the description supplies the remaining essential context: data scope, exclusions, pricing, and payment behavior. Nothing critical is missing for correct invocation.

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

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

Schema coverage is 100%, so the query and limit parameters are already fully documented. The description adds only that searching is by company name, which is already covered by the schema; baseline 3 is appropriate.

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

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

The description uses a specific verb (searches) and resource (Finland YTJ business register / PRH open data), and it clearly scopes the result fields. The mention of Finland distinguishes it from the many other country-registry 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?

It gives clear context for use: searching Finnish companies by name, with an explicit exclusion that it does not provide financial or credit information. It does not name alternatives such as other Finnish or Nordic registries, so it falls short of full when-to-use/when-not 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 readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely non-structured context: it is public open data, contains no credit score, and costs $0.002 USDC per successful call via x402 with failed calls uncharged — important for an agent deciding whether to incur cost. Pagination/return-shape detail is missing, keeping 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?

Two compact sentences, front-loaded with the resource and scope, followed by the pricing disclosure. No filler, though the field list (date, court, register number, URL) partially duplicates what the output schema already provides.

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

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

Given an output schema exists, return values need not be explained, and safety is covered by annotations. Combined with the pricing note and scope caveat, the description covers what an agent needs to call it, with only minor gaps around freshness/latency of 'latest' notices.

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 q (2-60 char free text over company name/town/court) and limit (1-25, default 10) are fully documented in the schema. The description only echoes the text filter and adds no syntax or behavioral detail beyond it, so the baseline 3 applies.

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

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

States a specific resource (France BODACC commercial announcements / official gazette open data) and the action (return latest notices, optionally text-filtered). It does not name or contrast with any sibling tool, so an agent cannot distinguish it from the many other registry/gazette tools by the description alone, but the purpose itself is unambiguous.

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

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

'Latest notices, optionally filtered by text' implies when to use it, and 'announcements only, no credit score' sets a scope boundary. However, there is no explicit when-not guidance and no pointer to an alternative sibling for related lookups, leaving routing to inference.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely non-derivable context: a $0.002 USDC per-successful-call charge via x402 on Base/Solana/Arc, and the guarantee that failed calls are not charged — important cost behavior an agent cannot infer from structured fields.

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

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

Two dense sentences front-loaded with what the tool returns, followed by exclusions and pricing. Every clause carries distinct information — scope, boundary, cost — 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?

An output schema exists, so return structure need not be explained. Given two optional params, an output schema, and read-only annotations, the description covers everything an agent needs to decide and call correctly: contents, filtering, exclusions, and payment terms.

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 q and limit are already documented including the range and default. The description only restates the optional word filter with examples and adds no new syntax, matching, or pagination detail beyond the schema; 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 the specific resource (G2 software categories), the exact fields returned (name, slug, G2 URL), the scale (~2,000 categories), and the source (G2's public category directory). It also states what the tool does not return, so an agent can distinguish it from review/rating-bearing directory siblings such as b2b_clutch_reviews or b2b_goodfirms_companies.

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

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

It implies usage via the optional word filter with concrete examples (crm, security) and clarifies the boundary that product lists, ratings, and reviews are excluded. However, it never names an alternative tool or states when to prefer this over the many other directory tools, so routing 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?

The readOnlyHint and openWorldHint annotations already cover the safety profile, while the description adds material behavioral context: $0.002 per successful call, x402 payment on Base/Solana/Arc, and failed calls not charged. It does not discuss pagination or rate limits, but the pricing and charging policy are substantial additions beyond annotations.

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

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

The description is a single dense sentence that front-loads the two usage modes and then covers returned fields and pricing. It has no filler, though the semicolon-heavy structure and pricing tail slightly reduce readability.

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

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

Given the full schema, output schema, and annotations, the description covers both operating modes, relevant inputs, returned fields, platform scope, and payment behavior. Nothing critical for correctly invoking the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents limit, company, country, and category. The description reinforces the mode semantics and the software-development-only country restriction, but adds little syntax or format detail beyond what the schema provides.

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

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

States the platform (GoodFirms), the resource (IT service companies), and the two output modes (ranked category list or single-company dossier) with returned fields. It clearly distinguishes list mode from dossier mode, but does not explicitly differentiate itself from sibling directories such as b2b_clutch_reviews or b2b_g2_software_categories.

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?

Explains that category/country selects list mode and a company slug selects dossier mode, which implies how to use the parameters. However, it gives no explicit when-to-use or when-not-to-use guidance relative to alternative company-review or directory 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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses the official CALC+ API source, the specific data fields returned, that rates are ceiling rather than invoiced prices, the exact per-call cost model, and that failed calls are not charged. These are material behavioral details for an agent deciding whether and how to invoke the 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 resource and its contents, then moves to search guidance, an important price caveat, and billing terms. Despite its density, every sentence carries useful information for invoking or interpreting the tool.

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

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

Given that an output schema exists and the annotations already signal read-only and open-world behavior, the description covers the remaining essentials: source authority, return contents, search semantics, price interpretation, and payment terms. Nothing critical for correct invocation appears to be 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 schema already documents both vendor and pages, including examples for vendor. The description reinforces that vendor accepts a contractor name or service keyword but adds little beyond the schema and does not clarify the pages parameter.

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

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

It names a specific resource, a US federal GSA schedule contractor dossier, and enumerates the exact contents: contracts, labor categories, ceiling prices, statistics, education, experience, and worksite mix. This is clearly distinguishable from generic company-directory siblings such as b2b_manta or b2b_yellowpages.

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 says to search by contractor name or a service keyword, which gives basic query guidance. However, it does not explicitly state when to use this tool versus adjacent government-contract tools such as gov_government_contract_awards, gov_sam_gov_wage_determinations, or gov_us_gov_contract_watch.

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 only covering read-only and open-world, the description adds real behavioral context: $0.002 USDC per successful call, x402 payment across Base/Solana/Arc, and that failed calls are not charged — critical for an agent deciding whether to spend. It also discloses the source-page ceiling ('up to ~60') and that NPI is derived from the profile id.

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 dense, front-loaded sentences: what you get, then how specialty is encoded, then price. The specialty-slug examples duplicate the schema's examples, a minor waste, but nothing else could be trimmed without losing value.

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

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

For a paid, single-page scrape with an output schema, the definition covers source, outputs, slug format, cap, and cost mechanics — enough to call it correctly. It omits error behavior for invalid slugs or unmatched city/state pairs, which matters for a paid call.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description restates the specialty slug convention and the ~60 cap that the schema's limit field already declares (1 to 60, default 20), so it adds little beyond the structured data.

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

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

States a specific resource and source: 'US doctors by specialty and city from Healthline FindCare', plus a concrete field inventory (name, address, phone, NPI, profile link). It differentiates by data source rather than by naming the closest siblings (b2b_webmd_healthcare_provider_directory, b2b_doximity, gov_npi_registry), so an agent must infer the distinction.

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

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

Usage is implied by the required inputs — query a specialty within a state/city — but there is no explicit when-to-use, when-not-to-use, or pointer to the WebMD/doximity/NPI alternatives for the same need. The paying-call note hints at cost tradeoffs but doesn't route the agent to a cheaper 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?

Goes well beyond the readOnlyHint/openWorldHint annotations: it discloses the large source file and slow first call after a cache miss, a $0.002 per-successful-call charge, the x402 payment rails (Base, Solana, Arc), and that failed calls are not charged. Cost and latency are exactly the operational 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?

Three sentences, front-loaded with what the tool returns, followed by data-quality caveat and then cost/latency. Every sentence carries distinct information; no filler or repetition of the name.

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

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

With an output schema present, return-value structure need not be described, and the description covers the remaining gaps an agent would care about: data nature (public, addresses only), performance characteristics, and payment mechanics. Nothing material is missing for correct invocation.

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

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

Schema description coverage is 100%, with both parameters already documented including defaults, so the baseline is 3. The description restates the window values and adds context that rows are 'top accounts', but says nothing about the limit parameter or its range, 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?

States a specific resource and verb: 'Hyperliquid public trader leaderboard: top accounts ranked by PnL' and enumerates the returned metrics (account value, ROI, traded volume). The domain is unmistakable against siblings like b2b_openllm_leaderboard and b2b_pgatour_leaderboard, which are different datasets entirely.

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?

Clearly frames the tool as a public on-chain stats lookup with selectable windows, and notes addresses only / no names, which sets expectations for what the agent will get. It does not explicitly name when to prefer a sibling or what to do when a query needs named traders, but the use case is unambiguous. Pricing and first-call latency also inform when to call 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 already declare readOnlyHint and openWorldHint, so safety is covered; the description adds genuinely new context: exact pricing ($0.002 USDC per successful call), the x402 payment rails (Base, Solana, Arc), and the important billing rule that failed calls are not charged. It stops short of disclosing result-set limits, pagination, or behavior when both parameters are passed simultaneously.

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

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

Two sentences, no filler, with the register identity and the search-vs-lookup distinction front-loaded before the field enumeration. The long mid-sentence field list ('name, registration date, other names, postal and legal address...') is dense but each item is informative; it is close to being a wall of 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?

An output schema exists, yet the description helpfully previews the returned record structure, and pricing/payment mechanics are spelled out — enough for an agent to call it correctly and know the cost. Minor gaps remain around pagination/result caps for the search mode and whether the two optional parameters can be combined.

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 goes beyond the schema by explaining the semantic distinction between the two parameters: 'name' triggers a search, while 'kennitala' returns the full record. It also restates the 10-digit format and confirms the response fields that kennitala unlocks.

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

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

Names the specific register (Fyrirtækjaskrá, Skatturinn) and states both operation modes: search by name/kennitala/address, or fetch the full public record for one company by 10-digit kennitala. The Icelandic jurisdiction and register identity cleanly separate it from the many sibling country registries (brreg Norway, bolagsverket Sweden, ireland_cro, etc.).

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

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

The two supported workflows are clear and the parameter-to-workflow mapping is implied well: pass a name for search, pass a kennitala for the full record. What is missing is explicit routing against siblings (e.g. 'use this only for Icelandic entities; use b2b_brreg_norway_companies for Norway') and any statement about what happens when no parameters are supplied, despite zero required parameters.

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 cover read-only and open-world; the description adds the commercially decisive behavior an agent cannot infer: $0.002 USDC per successful call, x402 payment across Base/Solana/Arc, and that failed calls are not charged. That is auth/payment and cost-transparency context that directly affects whether and how an agent invokes 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?

Two sentences, no filler: capability and scope first, cost/payment second. Every clause carries information an agent would otherwise lack, and the highest-value constraints are front-loaded.

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

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

For a one-parameter read tool with an output schema and read-only annotations, nothing decision-relevant is missing — scope, exclusions, cost, payment rails, and failure charging are all stated, and return fields need no further explanation given the 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% — the single 'q' parameter is already documented as a 2–80 character company name. The description's 'searches companies by name' merely restates that, adding no syntax, format, or matching-behavior detail, 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 and resource ('searches companies by name') plus the data domain (ImportYeti US import records) and enumerates what comes back (shipment counts, most recent shipment date, address, profile URL). The explicit scope statement 'Company search only, not individual bills of lading' distinguishes it from any shipment/BoL-oriented tool an agent might otherwise 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?

Gives a clear usage boundary ('Company search only, not individual bills of lading'), which functions as an explicit when-not rule and is the main misuse risk for this data domain. It stops short of naming an alternative tool for the excluded BoL use case, so it is clear context without full routing.

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 readOnlyHint/openWorldHint, the description discloses scope limits (first result page, ~10 listings) and a non-obvious cost model ($0.002 USDC per successful call via x402, failures not charged) — information an agent cannot get from annotations or schema. It does not say whether deeper paging exists or how rate limits behave, keeping it short of 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?

Two sentences, front-loaded with the core purpose, then scope and pricing. The field enumeration is dense and partly redundant with the output schema, but every clause is informational and nothing is 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?

An output schema exists, so the return-field list is redundant rather than necessary, but cost, payment rail, failure billing, and the first-page-only limitation cover the operational gaps. An agent has enough to call it correctly and interpret the result.

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

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

Schema coverage is 100% and both parameters are documented there, so the baseline is 3. The description only adds that the default page is 'about 10 listings', which loosely contextualizes the limit parameter but adds no syntax or constraint detail beyond the schema.

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

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

The description identifies the resource precisely: Indian wholesale suppliers/manufacturers on IndiaMART searched by product keyword, with a concrete field inventory. It is clearly distinguishable from siblings like thomasnet or yellowpages via the IndiaMART/India sourcing angle, though it lacks an explicit verb framing (it reads as a data inventory rather than 'searches X').

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

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

Usage is implied rather than stated: the product-keyword input and IndiaMART domain make the sourcing use case obvious, but there is no explicit when-to-use, when-not-to-use, or sibling routing (e.g., 'use thomasnet for US suppliers').

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 readOnlyHint/openWorldHint annotations, the description discloses the official open-data source, CC BY 4.0 license, daily update cadence, returned field set, and the paid x402 pricing model with failed calls not charged. This is exactly the kind of behavioral context an agent needs for a paid read-only data 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 compact and front-loads the source and operations before listing returned fields and pricing. It is dense but every element is useful; the long field list is justified by the tool's data-lookup nature.

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

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

Given the tool's complexity, a payment model, and an output schema already covering return values, the description provides enough source, licensing, update, lookup, and billing context to call it correctly. Nothing material appears to be 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 the input schema already documents all four parameters with examples such as 'ryanair' and '104547'. The description reinforces the name vs. company-number lookup paths but adds no additional syntax, defaults, or paging details beyond the schema.

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

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

The description states a specific resource (Irish companies from the CRO), the operation (search by name or look up by company number), and the data provenance. It clearly distinguishes itself from the many other country/company registry siblings through the Ireland/CRO scope.

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

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

It tells the agent the two supported access patterns: search by company name or look up a company number, which maps naturally to the schema parameters. It does not explicitly say when not to use it or name alternative sibling tools, 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 readOnlyHint and openWorldHint, so the safe-read profile is covered. The description adds non-obvious operational detail beyond that: per-call pricing ($0.002 USDC), the x402 payment rails (Base, Solana, Arc), and that failed calls are not charged. Remaining gap is nothing about rate limits or response size, so not 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?

Information is front-loaded: source, verb, returned fields, exclusions, then pricing. It is dense but every clause carries signal; the returned-field list is slightly redundant given the output schema but is not wasteful filler.

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

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

For a 2-parameter read-only lookup with an output schema, the description covers source provenance, scope exclusions, and billing behavior. The output schema handles return values, though the description repeats them; nothing essential for calling 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% and both parameters are documented in the schema. The description only echoes the name-query behavior ('Hebrew or English name') already captured by the q description, adding no format or range guidance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: 'searches companies' against the 'Israel Companies Registrar (Ministry of Justice open data, data.gov.il)'. It also scopes the dataset by naming the returned fields and explicitly excluding financials and officers, so an agent can distinguish it from the other country-registry 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?

Clear usage context: query by company name in Hebrew or English, and the source is the official Israeli register. It gives useful boundaries ('Public register extract; no financial data, no officers'), which implicitly routes agents needing officers or financials elsewhere, but it does not name an 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 establish that this is a read-only, open-world operation, and the description adds material behavioral context beyond them: exact pricing ($0.002 USDC per successful call), payment rails (x402 on Base, Solana, or Arc), and the crucial guarantee that failed calls are not charged. It also discloses the return contents for both listing and detail modes.

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

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

The description is front-loaded with the primary retrieval behavior, then the conditional single-job mode, then pricing. Despite being dense, every clause carries operational value, including the payment caveat, and there is no wasted filler.

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

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

Given that an output schema exists, the description does not need to exhaustively document return fields, but it still summarizes both listing and posting outputs. With annotations covering safety, schema covering all parameters, and pricing/failure terms explicitly stated, the definition is complete enough 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 description coverage is 100%, so every parameter is already documented: company as the Jobvite slug, job as an optional job id from a listing, and q as an optional keyword filter. The description reinforces the company slug pattern (jobs.jobvite.com/<company>) and the job-id mode, but this largely repeats schema content rather than adding new parameter semantics.

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

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

The description states a specific verb and resource: retrieving open jobs from Jobvite careers sites. It clearly covers both listing and single-posting modes, but it does not explicitly differentiate itself from any sibling tool by name, so it falls just short of the 5 benchmark.

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

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

The description gives clear conditional usage: omit the job id to list all open positions with department and location signals, or supply a job id to retrieve that posting's full details. It does not mention when not to use the tool or name alternative sibling tools, so it earns a 4 rather than a 5.

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

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

Beyond the readOnlyHint, the description discloses several behaviors an agent could not infer: it adds no outside data, it flags invalid emails rather than dropping them, and it carries a per-call price of $0.002 USDC via x402 with failed calls uncharged. Those are genuinely valuable operational facts. There is mild tension with openWorldHint=true given the 'adds no outside data' claim, but that hint plausibly refers to arbitrary user-supplied input rather than external fetching, so it is not a real contradiction.

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 core capability is front-loaded in the first clause and the sentence stays dense with concrete operations. Minor waste in the redundant 'Lead formatter:' opener that restates the title, and the pricing sentence, while necessary, could be its own short trailing line.

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 annotations covering safety, a fully described single parameter, and an output schema handling return values, the description supplies the remaining essentials: scope (supplied records only), transformations, invalidity handling, and cost/payment terms. Nothing critical for correct invocation appears to be 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% and the single parameter already documents the accepted fields and the 50-object cap. The description reiterates the same field list and describes the per-field normalization, which is helpful but largely mirrors what the schema and the promised behavior already convey, 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?

The description names a specific verb (cleans/formats) and resource (a supplied list of contact records) and enumerates the exact transformations performed (trim spaces, fix casing, lowercase emails/domains, keep phone digits, flag invalid emails). The line 'It adds no outside data' sharply separates it from the sibling tools, which are all data-source lookups, so an agent can immediately tell this is a local normalization step rather than a retrieval.

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 makes clear the tool operates only on records the caller supplies and enriches nothing, which implicitly establishes when to reach for it (post-retrieval cleanup) versus the lookup siblings. It does not explicitly name an alternative or state when not to use it, and the pricing note is useful context but not 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?

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing the data provenance (public schema.org markup, no authentication), the cost model ($0.002 USDC per successful call via x402 on Base, Solana or Arc), and the failure policy (failed calls are not charged). Those billing and access details are exactly what an agent needs before invoking a paid endpoint and are unavailable in structured fields.

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

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

Three tight sentences: what you get, what you don't get, what it costs. Scope is front-loaded and the pricing caveat is placed where it can be read before the call, with zero 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?

With an output schema present, return values need not be described, and the description covers scope, exclusions, data provenance, auth requirement and cost. Nothing an agent needs to decide and invoke 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% and the single parameter already documents that a slug or full company URL is accepted, so the description adds little parameter-level detail. Nothing is wrong, but it does not supplement the schema with format examples or slug-normalization behavior.

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

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

Names a specific resource (public LinkedIn company page facts) and enumerates the exact fields returned: name, description, HQ address, employee count band, website links, logo. It also explicitly excludes posts, followers and people, which separates it from any LinkedIn-adjacent sibling at a glance.

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

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

States the source and access condition ('schema.org data LinkedIn publishes on the public company page (no login)') and draws a clear negative boundary ('Posts, followers and people are not included'), which tells an agent when not to use it. It stops short of naming a direct alternative tool for those excluded 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?

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds meaningful behavioral context beyond annotations, especially the $0.002 USDC cost, x402 payment networks, and that failed calls are not charged. It does not cover rate limits or freshness guarantees, but the billing and scope transparency are strong.

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

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

Purpose and scope are front-loaded, followed by returned fields and pricing. The return-field list is somewhat dense, but it is useful and the description avoids unnecessary filler.

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

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

Given the output schema and full parameter coverage, the description does not need to explain return values in detail, though it helpfully lists them. It includes pricing and billing behavior, leaving only minor optional context such as rate limits or data recency 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 q and limit parameters are already documented in the schema. The description reinforces keyword search but adds no new syntax, default, or constraint details beyond what the schema provides.

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

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

States a specific verb and resource: finds podcasts by keyword via Listen Notes. The description also scopes it to podcast metadata only, which clearly distinguishes it from the many business/government directory siblings.

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

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

Provides clear usage context: keyword-based podcast search returning podcast metadata. It does not explicitly name when to prefer an alternative or when not to use it, so it falls short of the explicit when/when-not test.

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 and openWorldHint, but the description adds genuinely non-obvious operational context: a $0.002 USDC charge per successful call, the x402 payment rail (Base, Solana, Arc), and that failed calls are not charged. This is exactly the kind of cost/auth detail an agent needs before invoking. Minor gap: the phrase 'Public free API' sits slightly awkwardly next to the per-call price (it describes the upstream registry, not this wrapper) and invalid-MAC behavior isn't described.

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: purpose and source first, scope limit second, cost/payment last. Nothing is redundant and the most decision-relevant facts are front-loaded.

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

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

An output schema exists, so return-value detail is unnecessary. The description covers source, scope, cost, payment mechanism, and billing on failure — everything an agent needs to decide to call a paid single-lookup tool with one required parameter.

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 both accepted forms with examples. The description repeats 'MAC address or OUI prefix' without adding format, normalization, or case-sensitivity guidance beyond what the schema 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 verb+resource (MAC address vendor lookup) and the exact output (registered hardware vendor for a MAC address or OUI prefix), plus the underlying data source (IEEE OUI registry via macvendors.com). No sibling tool overlaps this domain, so the agent can immediately tell this is the only relevant choice.

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

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

The description makes clear the input domain (MAC or OUI prefix) and explicitly bounds the result (vendor name only, no device data), which tells an agent when this tool is and is not sufficient. It stops short of naming alternatives or stating when to avoid the tool, 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?

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing the underlying access path (residential proxy), result density (~10 per page), and the billing model ($0.01 USDC per successful call via x402 on Base/Solana/Arc, failures free). It stops short of covering rate limits, latency, or failure modes, but the cost disclosure is exactly the kind of context an agent needs before spending.

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 search scope and followed by the commercial terms. It is dense but every clause carries information; the field inventory is somewhat list-like and arguably redundant with the 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 an output schema present, the return-value burden is already handled, yet the description still summarizes fields. Combined with disclosed pricing, paging, and data source, an agent has enough to call it correctly; the missing piece is guidance on when to prefer a different directory source.

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 all four parameters are already documented with examples in the schema. The description only restates keyword plus city/state and adds 'about 10 per page', which implies the paging behavior but adds no new constraint (like the 1-10 page bound) 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 ('Manta US small-business directory search by keyword and city/state') and enumerates the returned fields, so the agent knows exactly what comes back. It does not explicitly name how it differs from nearby directory siblings like b2b_yellowpages or b2b_google_maps, leaving that distinction to be inferred from the source name.

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 search inputs are named, which implies when the tool applies, and 'about 10 per page' hints at paging. However, there is no explicit when-to-use/when-not guidance and no routing to alternative directory tools when a query is not a US local business.

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 and openWorldHint, and the description adds substantial beyond them: the exact cost ($0.002 USDC per successful call), the payment rails (x402 on Base, Solana or Arc), and the refund behavior for failed calls. It also discloses the authoritative-source constraint and that results include a total match count. These are material operational traits an agent cannot get from structured fields.

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

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

The core capability and its scoping are front-loaded, followed by the alternative source and then pricing. Every element is relevant, though the single long sentence with stacked parentheticals is dense and could be split for 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?

An output schema exists, so return formatting needn't be explained, and the description still notes that a total match count is returned. Combined with read-only/openWorld annotations, the source authority note, and full pricing disclosure, an agent has everything needed 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?

With 100% schema description coverage, the schema already documents all seven parameters including the prefix semantics for names and the state/province code format. The description restates the filter set (last name, first name, city, state/province, country) without adding syntax or format detail beyond the schema. Baseline 3 applies because the schema carries this dimension.

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 (retrieve NCARB-certified architects from the official Certificate Lookup) and enumerates the returned fields (name, city, state/province, country) plus the total match count. It also states the population definition (US certificate holders licensed in at least one US jurisdiction), which separates it from generic architect directories. It does not explicitly name a sibling tool, so it stops short of 5.

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

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

It gives an explicit exclusion-plus-alternative: 'To confirm a specific license number use the state board roster,' which tells the agent when this source is insufficient. The filtering options are described, giving clear context for use. However, the alternative named is an external data source rather than a sibling tool, and there is no guidance on when to prefer this over other people/business directories in the catalog.

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 open-world, and the description adds substantive behavioral facts beyond them: data provenance and monthly update cadence, and a paid-call model ($0.002 USDC per successful call via x402, no charge on failure). The cost/auth and freshness signal is exactly the kind of context 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?

Purpose, scope and limitations are front-loaded, with cost and freshness trailing. The result is dense but every clause carries information; the only minor cost is a long single sentence packing pricing into the same breath as data scope.

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

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

With an output schema present, the description need not explain return values, and it still supplies the scope, freshness, provenance and payment model. Nothing material for correct invocation appears to be 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 both parameters are fully documented in the schema (name-part syntax, 2-80 chars; limit 1-25 default 10). The description adds only a high-level 'searches by entity name' framing, 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?

States a specific verb+resource (searches New York Department of State active corporations by entity name) and enumerates returned fields, so an agent can distinguish it from NYC-license or other state-registry siblings without opening the schema. It also pre-empts the closest misreading by declaring it is 'not a credit or ownership 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?

Gives useful selection context: public open data, monthly refresh, and explicit negative guidance that it is not a credit/ownership report. It does not name specific alternatives among the many registry siblings (e.g., b2b_nyc_business_licenses, gov_sunbiz_florida_business), so routing is clear but not fully prescriptive.

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 readOnly/openWorld; the description adds the crucial behavioral facts: it is Socrata public open data, and it costs $0.002 USDC per successful call via x402 on Base/Solana/Arc with failed calls uncharged. That payment/cost behavior is invisible to annotations and directly affects agent decision-making.

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, purpose front-loaded, then provenance and pricing. The return-field enumeration is partly redundant with the existing output schema, which is the only minor waste.

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

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

With an output schema present and full parameter coverage, the description only needs to supply scope, provenance and cost — all of which it does. An agent has everything required to call it and to decide whether the paid call is worth making.

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 q and limit are already documented with constraints (2–60 chars, 1–25 rows, default 10). The description only restates that q is a business-name search, adding no format or edge-case detail beyond 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 source (NYC Department of Consumer and Worker Protection license list), a specific action (searches by business name), and the returned fields. An agent can distinguish it from b2b_chicago_business_licenses or b2b_nyc_certified_business from the text alone.

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

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

'Searches by business name' and 'license rows only' imply the applicable case and implicitly exclude other NYC datasets, but no alternative sibling is named and no exclusion conditions are stated explicitly.

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 establish read-only and open-world behavior, and the description adds meaningful context: the data is public, owner contact and personal fields are intentionally excluded, and pricing is charged only on successful calls. It does not describe pagination or response shape, but the output schema exists and the added behavioral details are useful.

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

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

The description is compact and front-loaded: purpose and source appear first, followed by privacy and pricing details. Every sentence contributes useful information without unnecessary repetition.

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

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

For a simple two-parameter search tool with a full input schema and an output schema, the description covers the essential context: data source, search basis, return fields, privacy exclusions, and payment model. An agent has enough information to call it correctly without needing further 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 description coverage is 100%, so the schema already documents q and limit thoroughly. The description adds that q matches formal or trade names, which is a slight semantic enrichment, but it does not expand on limit behavior beyond the schema.

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

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

The description gives a specific verb and resource: it searches vendors in the NYC Small Business Services certified business list and states the returned fields. It is clear enough to distinguish from generic business directories, though it does not explicitly contrast with nearby siblings such as b2b_nyc_business_licenses or b2b_ny_business_entity.

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

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

The description implies that this is a name-search tool for certified NYC businesses, but it does not say when to use it instead of related tools like NYC business licenses or NY business entity search. It also gives no explicit exclusions or selection guidance beyond the query being by formal or trade name.

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 (readOnlyHint, openWorldHint), and the description adds substantive context beyond them: the upstream data source, the price of $0.002 USDC per successful call, accepted payment rails, and the fact that failed calls are not charged. It omits rate limits and result ordering, which are the only notable behavioral gaps.

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

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

Two sentences, front-loaded with the core lookup behavior, followed by the scope exclusion and pricing. Every sentence carries information, though the payment-rail parenthetical is slightly dense for the space it occupies.

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 low-complexity search tool with an output schema, full parameter coverage and safety annotations, the description supplies what remains: data provenance, scope boundaries and cost model. Only minor gaps like result ordering or rate limits keep it from a 5.

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 q, limit and exchange are already fully documented in the schema. The description reinforces that lookup works by ticker or security name and mentions the exchange-code field implicitly through the returned fields, but adds no syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb+resource: searches NYSE-listed symbols from the Nasdaq Trader otherlisted file by ticker or security name, and enumerates returned fields. It also explicitly distinguishes the scope from adjacent tools ('Symbol directory only, no prices or company profiles'), so an agent can separate it from siblings like b2b_euronext_equities or profile-oriented directories.

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

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

It gives clear context — a symbol/name lookup over the otherlisted file — and explicitly rules out price or company-profile use cases. It does not name an alternative tool or say when a different sibling should be preferred, which keeps it below 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 and openWorldHint, but the description adds substantial context beyond them: the pricing model ($0.002 USDC per successful call via x402 on Base/Solana/Arc), that failed calls are not charged, the 15-per-page paging, and that a total match count is returned. This billing/auth detail is genuinely valuable and not captured by 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?

Dense but front-loaded: the resource and scope come first, followed by returned fields, paging, source, and pricing. Every sentence carries information, though the field enumeration and the pricing clause make it a fairly long single paragraph.

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, single-required-parameter search tool with an output schema, the description covers source, scope, returned fields, paging, and cost. Nothing an agent needs to invoke it correctly and anticipate charges is missing.

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

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

Schema coverage is 100%, so the schema already documents query, status, and page. The description restates the 15-per-page paging and adds the returned field list, but does not add syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource (New Zealand Companies Register search via the official NZ Companies Office) and enumerates the returned fields (name, number, NZBN, status, entity type, address, incorporation date). This clearly distinguishes it from the many other country/registry siblings such as b2b_brreg_norway_companies or b2b_ireland_cro_companies.

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

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

The description implies usage context (keyword search against the NZ public register, with a status filter) but never explicitly states when to prefer this over a sibling registry or when it is the wrong choice. An agent can infer the domain from the name, but no explicit exclusions or alternatives are given.

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

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

Annotations already declare readOnlyHint and openWorldHint, but the description adds materially new behavioral facts: a cost of $0.002 USDC per successful call, x402 payment on Base/Solana/Arc, and that failed calls are not charged. The 'not medical advice' disclaimer further sets expectations. This is behavior an agent must know before invoking and is not derivable from structured fields.

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

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

Three sentences, front-loaded with the capability and its returned fields, then the disclaimer, then the pricing terms. Each sentence carries distinct information (capability, legal caveat, cost model) and there is no filler.

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

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

With an output schema present, the description need not explain return structure, and annotations cover safety. The description still supplies the two things structured data lacks: the domain scope (US FDA drug listings by name) and the payment terms. Nothing an agent needs to decide to call or to invoke 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%, so both q (2-60 chars, allowed characters) and limit (1-25, default 10) are fully documented in the schema. The description restates that searching is by brand or generic name but adds no syntax, format, or edge-case guidance beyond that. Baseline 3 is appropriate when 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?

States a specific verb (searches) plus a precise resource (openFDA National Drug Code directory of US drug listings), and enumerates the returned fields (labeler, NDC code, dosage form, route, marketing start date, active ingredients). An agent can distinguish this from the many other registry/directory siblings without opening a 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?

Clearly indicates the search axis (brand or generic name) and that the dataset is US-specific and public, which tells the agent when this tool is appropriate. It does not name alternatives such as gov_openfda_drugsfda or gov_anvisa_brazil_medicines or state exclusions, so it stops short of full when/when-not 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?

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing the monetization model ($0.002 USDC per successful call, x402 on Base/Solana/Arc), the no-charge-on-failure policy, the dataset's archival date, and result ordering. These are material facts an agent cannot infer from structured fields.

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

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

A single dense sentence that front-loads the identity and purpose before the field list and pricing. Efficient with no filler, though the enumeration of returned metrics is lengthy and partly duplicates the 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?

The complexity here is low (2 params, output schema present), and the description covers purpose, ordering, staleness, and payment requirements. Remaining details like exact response shape and pagination are handled by the output schema and the limit parameter.

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 'q' length bounds and 'limit' range/default are already fully documented. The description only adds that the query targets a model name and that results are ranked by average score, which is marginal 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 ('finds open-source language models by name'), names the exact dataset (Open LLM Leaderboard v2), scopes it to 4,576 rows, and enumerates the returned fields plus sort order. This clearly separates it from siblings like b2b_pgatour_leaderboard and b2b_hyperliquid_leaderboard despite the shared 'leaderboard' naming.

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 name-search use case and its constraint (model name part) make the intended invocation obvious, and the 'best average first' ordering tells an agent what it gets by default. No explicit when-not or alternative is named, but the domain is narrow enough that none is really needed.

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 and openWorldHint, but the description adds materially useful context those don't cover: the metered price ($0.002 USDC per successful call), the x402 payment rails (Base, Solana, Arc), and the fact that failed calls aren't charged. That payment/auth disclosure is exactly the kind of pre-call cost awareness an agent needs. It stops short of stating data recency or coverage caveats, so not 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?

Two sentences, no filler, and the domain/purpose is front-loaded ahead of the pricing detail. The first sentence is a dense comma-list of returned fields, which is information-rich but slightly inventory-like rather than structurally organized; still, nothing is wasted.

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

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

With an output schema present, the description needn't spell out return values, and annotations carry the safety profile; the description covers domain scope (US), identifier formats, and cost/payment mechanics. What's missing is any note on data freshness or what happens for unmatched employers, which matters for a paid, open-world 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% and the single 'employer' parameter is already documented with three concrete key examples plus URL support. The description restates the key format ('e.g. Microsoft_Corp') and adds 'or name,' which mirrors rather than extends the schema. 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 domain and resource: 'US employer pay and benefits from PayScale,' then enumerates exactly what data comes back (benefit types, percentiles, satisfaction, locations). An agent can tell this is a compensation/benefits lookup, distinct from generic company-profile siblings like b2b_linkedin_company_profiles or b2b_similarweb, though it never explicitly contrasts itself with them.

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

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

Usage is only implied by the data inventory — an agent infers it should call this when it needs employer pay/benefits figures. There is no explicit 'use this when…' statement and no named alternative for related needs (e.g., headcount or web traffic, which other siblings cover). The one concrete usability hint is the accepted employer identifier format.

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 and openWorldHint, so the safety profile is covered; the description still adds meaningful context the annotations cannot: the data is unofficial ESPN data, the leaderboard may legitimately be empty, and each successful call costs $0.002 while failures are free. It does not discuss data freshness/caching or pagination, which keeps it from 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?

Purpose and scope are front-loaded in the first clause, with caveats (unofficial source, empty list) and then pricing in a separate, well-placed sentence. Every sentence carries information; the pricing detail is long but operationally necessary for a paid endpoint.

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 zero parameters, an output schema present, and annotations covering read-only/open-world behavior, the remaining gaps an agent would face are provenance, cost, and edge-case returns — all three are stated. Nothing needed to invoke or interpret the call 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?

The tool takes no parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly does not invent parameter talk and instead spends its words on scope and cost.

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 the returned fields: tournament name, dates, status, and player leaderboard. It also pins the source (ESPN's public scoreboard) and scope (current and upcoming events). It stops short of explicitly contrasting itself with the leaderboard siblings (b2b_hyperliquid_leaderboard, b2b_openllm_leaderboard), though the domain makes confusion unlikely.

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

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

Usage context is clear: call it to get current/upcoming PGA Tour events and the live player leaderboard. The 'empty list before the first round' caveat tells the agent what a pre-tournament result looks like, preventing misinterpretation. No explicit when-not or alternative tools are named, but none are plausibly needed for this domain.

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/openWorld annotations, the description discloses the commercial model: $0.002 USDC per successful call via x402 on Base/Solana/Arc, with failed calls not charged. That cost and payment-path disclosure is real behavioral context an agent cannot get from annotations, and it also clarifies the 30-newest-reviews cap.

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 resource and geography, then the field inventory, then the parameter rule and price. It is dense and waste-free, though the long return-field enumeration partially duplicates what the existing output schema already exposes.

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, three-parameter lookup with an output schema, the description covers everything an agent needs: source, geography, identifier format, payload contents, and cost/billing behavior. Nothing material is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description echoes the schema's company example (kfc-432299) and implies the limit ceiling via 'the 30 newest reviews', but adds essentially no new meaning about the country toggle or the limit string type.

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 (employer reviews from SEEK) and immediately scopes it geographically to Australia/New Zealand, which separates it from generic review siblings like b2b_trustpilot_reviews, b2b_clutch_reviews or b2b_g2_software_categories. It also enumerates the returned payload, so an agent knows exactly what data it gets.

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

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

Usage is only implied: an agent can infer it should call this for Australia/NZ employer-review data, but the description never states when to use it instead of the sibling review or company-benefits tools, nor any prerequisites (e.g. that a SEEK slug must be resolved first). Guidance is adequate but leaves the routing decision 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 establish readOnly and openWorld behavior, but the description adds substantial operational context: data comes from similarweb.com via a stealth proxy, pricing is $0.05 USDC per successful call via x402 on Base, Solana, or Arc, and failed calls are not charged. This is meaningful transparency beyond 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?

The description is front-loaded with purpose and scope, and the pricing caveat is placed at the end. The long list of returned data fields is somewhat verbose given that an output schema exists, but each item still helps an agent understand the tool's coverage.

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 required parameter, readOnly/openWorld annotations, and an output schema, the description provides everything an agent needs: what the tool returns, recency of data, source, proxy behavior, and payment/charging rules. No critical calling context 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 'domain' parameter is already documented with an example in the schema. The description does not add syntax, formatting, or validation details beyond what the schema provides, 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?

The description gives a specific verb and resource: 'Similarweb traffic overview for a domain', and scopes it to public page data from the last full month. It is clearly distinct from the directory/registry siblings, though it does not explicitly differentiate itself from any closely related analytics tool.

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

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

The parenthetical 'public page data, last full month' implies the appropriate context for using the tool, but the description does not state when to use it versus alternatives or any exclusions. Usage is implied rather than explicitly guided.

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