UK Data for Agents

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

No annotations are supplied, so the description carries the full disclosure burden. It usefully reveals that results include abstracts and PDF links and that each call costs 1 credit, but says nothing about ordering, pagination, result caps, or failure behavior for malformed queries.

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: the capability and its return content come first, with the credit cost appended in parentheses. Nothing is redundant or buried.

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 read tool with no output schema and no annotations, the description covers what it does, what it returns, and its cost. The remaining gaps (query syntax, pagination/limit semantics) are modest rather than blocking.

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 (query, limit with range 1-50) are already documented in structured form. The description adds no query syntax hints (e.g., field prefixes, boolean operators, category filters) that would go 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?

"Search arXiv preprints" gives a specific verb and resource, and naming arXiv distinguishes it from pubmed_search and doi_lookup. It also states what comes back (abstracts, PDF links), though it never contrasts itself with papers_search, which may overlap.

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 via the arXiv domain name; there is no explicit when-to-use or when-not-to-use guidance and no mention of papers_search as the alternative for cross-source or non-arXiv queries. An agent can infer the source scoping but must reason about sibling overlap itself.

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

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

With no annotations, the description carries the full load, and it does disclose something genuinely useful in the credit cost and the gov.uk data source. It does not state that this is a read-only lookup or what the results look like, so the safety profile and response shape remain implicit.

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

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

Two tight fragments with the subject front-loaded and the cost caveat parenthesized at the end. Nothing is wasted, though the telegraphic style leaves the description thin rather than rich.

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-param lookup with no output schema and no annotations, the description is adequate but leaves real gaps. Both params are optional, yet there is no mention of what happens when year or division is omitted, and no hint of the returned fields.

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

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

Schema coverage is 100%, with 'year' documented as YYYY and 'division' listing the three valid values, so the schema does the heavy lifting. The phrase 'by division and year' only restates what the params already convey, adding no syntax or default information.

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: UK bank holidays by division and year, sourced from gov.uk. The 'UK' qualifier implicitly separates it from the generic public_holidays sibling, but that differentiation is never made explicit.

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

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

No guidance on when to use this versus public_holidays, working_days, or holiday_entitlement, which are the obvious adjacent tools. The agent must infer that this is the UK-specific path.

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

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

No annotations are supplied, so the description carries the full burden. It does disclose a genuinely useful behavioral trait — a cost of 1 credit — plus the default series behavior, but says nothing about return format, data frequency, latency, or error behavior for unknown series codes.

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

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

A single dense sentence with the resource named first and cost appended in parentheses — nothing is padded. The trailing 'and more' is slightly vague, but overall the structure is front-loaded and efficient.

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

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

For a three-parameter read tool with no annotations and no output schema, the definition covers the identifier space but leaves the return shape (dates, values, units, frequency) entirely unexplained. Adequate to invoke, thin for interpreting results.

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

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

Schema coverage is 100%, so the baseline is 3, but the description earns an upgrade: the schema only says 'string, comma list allowed' for series, while the description supplies real series identifiers and identifies the default. It adds no extra detail on from/to beyond the schema's YYYY-MM-DD format.

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: retrieving Bank of England database series, with three concrete series identifiers (IUDBEDR, XUDLUSS, IUMBV34) that make the data domain unmistakable. It does not distinguish itself from the overlapping siblings fx_rates, hmrc_exchange_rates, or ons_timeseries, which is why it falls short of a 5.

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

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

The description implies usage by naming example series codes and marking IUDBEDR as the default, but never says when to choose this over fx_rates or ons_timeseries, nor when a date range is required. With all parameters optional, the agent gets no guidance on what happens if it calls with no arguments.

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

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

No annotations exist, so the description carries the full burden — it does add genuinely useful information in disclosing the cost ('1 credit'), which is not in any structured field. It omits other behavior an agent needs: whether pagination is supported, whether results are capped by default, and how conflicting parameters are resolved.

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

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

Two short sentences, front-loaded with the primary capability and no wasted wording; the cost note is a separate parenthetical that earns its place. Slightly under-specified rather than over-long, which is the right failure mode for this style.

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

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

With no annotations and no output schema, the description is the only source of behavioral information, and it leaves the key ambiguity of a zero-required-parameter tool unresolved: precedence between isbn and query, and behavior with no arguments. For a simple lookup tool this is a meaningful gap rather than a minor one.

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

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

Schema description coverage is 100%, so the baseline is 3. The description maps isbn to detail retrieval and query to title/author search, adding a little meaning, but it doesn't clarify whether query matches title and author simultaneously, nor does it explain the limit range (1-25) beyond what the schema already 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 ('Book details', 'search books') and states the two supported access modes (ISBN lookup vs. title/author search). It does not reference any sibling tool, but none of the listed siblings (wikipedia_summary, arxiv_search, papers_search) overlap directly, so differentiation is less critical here.

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 modes imply when to use each parameter (ISBN for a known book, query for discovery), but this is inference rather than guidance. It never states what happens if both isbn and query are supplied, or what occurs when neither is, which matters because the schema declares 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?

With no annotations, the description carries the full behavioral burden, and it does disclose a genuinely useful operational detail the schema cannot: the cost of 1 credit per call. It also implicitly reveals the tool is a pure computation with no side effects by listing only math functions. But it says nothing about the return shape for the statistics mode (mean, median, count?), numeric precision, or how invalid expressions are reported, which are the details an agent most needs.

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

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

Two compact clauses front-load the capability and the parenthetical function list is dense but each item earns its place by defining the accepted grammar. The cost note is appended efficiently rather than buried. Minor deduction because the parenthetical enumeration slightly crowds the opening sentence.

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

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

With no output schema and no annotations, the description should close the loop on what a statistics call actually returns, and it does not — the word "summary statistics" is left undefined. For a simple two-parameter computation tool the coverage is close to adequate, but the missing return-value detail is the one gap that could force a trial 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 would be 3, but the description earns above that by supplying the expression grammar — the allowed operators and functions (sqrt, ln, log, round, min, max, pi) — which the schema only labels as an untyped "string". It also clarifies that "values" is a number collection, consistent with the schema's "array or comma list of numbers".

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 ("Evaluate") and two concrete resource modes (an expression, or summary statistics of a number list), and it enumerates the supported operators and functions, which tells an agent exactly what the tool can compute. It does not differentiate against near-neighbours like text_stats or convert_units, but the sibling list is largely unrelated utilities, so the purpose is still unambiguous.

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

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

The two operating modes are stated, and by implication "expression" drives the expression mode while "values" drives the statistics mode, so an agent can infer which parameter to populate. However, there is no explicit when-to-use framing, no statement of what happens if both parameters are supplied, and no note on which statistics are produced.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it discloses only cost ('costs what the tool costs', '1 credit'). It says nothing about error behavior when a tool name is invalid, whether arbitrary/destructive sibling tools can be reached, permission requirements, or how args are serialized — significant gaps for a tool that can invoke anything.

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

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

Two short sentences, front-loaded with the core mechanic, with no filler. The trailing '(cost: 1 credit)' partially restates 'costs what the tool costs' and adds slight ambiguity about whether the credit is per call or per nested 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?

There is no output schema and no annotations, and the sibling set is ~90 tools, so the description needs to be more self-sufficient than it is. It omits tool-name discovery, error/return shape, and args encoding, though the cost note and the api__ prefix hint cover part of what a caller needs.

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 one genuinely useful clarification — that args is an arguments object, which resolves the schema's odd 'type: string' declaration — but it does not explain how to encode that object (raw JSON vs stringified) or what name accepts beyond 'any tool'.

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

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

States a specific verb and resource: 'Call any tool by name with an arguments object', and clarifies scope by including imported API operations (api__operation). An agent can tell this is a generic dispatcher rather than a domain tool, though it never names a concrete case where dispatch beats calling a sibling directly.

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

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

The mention of 'imported API operations (api__operation)' implies a naming convention for tools not in the native list, which is useful. But there is no explicit when-to-use versus when to call a sibling tool directly, and no pointer to tool_search or list_apis for discovering valid tool names — the single biggest practical question for a dispatcher.

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

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

With no annotations, the description usefully conveys a current-data lookup and discloses the one-credit cost. However, it leaves the data source, refresh cadence, and behavior for invalid postcodes unstated.

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, covering purpose, scope, output content, and cost without filler. The parenthetical cost disclosure is efficient and easy to notice.

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 one-parameter lookup, it provides enough information to select the tool and generally invoke it correctly. With no output schema, the lack of intensity units, source or freshness details, and precise postcode syntax are noticeable but not fundamental gaps.

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

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

Although schema coverage is reported as complete, the schema's "string" description adds little; the main description connects postcode to regional intensity and implies that national results are available without it. Accepted postcode granularity or format remains undocumented.

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 precisely identifies the resource, temporal scope, geography, and included generation mix: current GB grid carbon intensity at national or postcode-region level. This clearly distinguishes it from weather and other lookup 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?

"Current" and the national-versus-postcode-region distinction give clear selection context and implicitly exclude historical or forecast lookups. It does not explicitly say to omit postcode for national results or identify any 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?

No annotations are supplied, so the description carries the full burden. It usefully discloses the cost ('1 credit') and that this is a read of register data, but says nothing about behavior for an unknown/non-registered number, whether financial figures are per financial year, currency, 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?

A single front-loaded sentence delivering the source register, the identifier, the returned fields, and the cost. Nothing is padded or redundant.

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

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

With one parameter, no output schema and no annotations, the description does the heavy lifting well by listing the fields returned. It falls short only on input format and error behavior for invalid charity numbers.

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

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

Schema coverage is 100%, but the schema text is only 'string, required', so the description's 'registered charity number' does add the meaning of the single parameter. However, it gives no format guidance (e.g. numeric string, digits only), so it does not fully compensate for the thin 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 ('Charity Commission register details') keyed by a specific identifier ('registered charity number') and enumerates the returned fields (status, income, expenditure, activities, address). No sibling tool covers charities, so differentiation is moot, but an agent instantly knows what this does.

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

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

Offers no explicit when-to-use or when-not-to-use guidance, no note on where to obtain a registered charity number, and no mention of related tools (e.g. company_search for non-charity entities). Usage is only inferable from the phrase 'for a registered charity number'.

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

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

With no annotations supplied, the description carries the full burden, and it does disclose a real behavioral trait beyond the schema: a cost of 1 credit per call, plus the extra payload (eligibility criteria, sites) returned in the detail mode. It says nothing about what happens with an unknown NCT id, whether results are paginated, or what a zero-filter call returns.

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

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

A single sentence with both modes front-loaded and the credit cost tucked in parentheses, so nothing is padded. The "or get one by NCT id" pivot is slightly telegraphic but does not obscure meaning.

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

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

There is no output schema and no annotations, so the description must cover both purpose and behavior; it identifies both call shapes and the cost. The remaining gap is the all-optional parameter set — an agent cannot tell from this text whether a filterless call is a valid bulk listing or an error.

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

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

Schema coverage is nominally 100%, but the per-parameter descriptions are type stubs ("string", "number 1-50"), so the schema conveys field names and little else. The description adds meaning only for nctId, leaving condition, intervention, location, status, and limit semantics to inference; the high coverage figure keeps this at the baseline 3.

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

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

Names a specific verb and resource ("Search clinical trials") and distinguishes two modes: a search and a single-record fetch by NCT id that returns eligibility criteria and sites. No sibling covers clinical trials, so the differentiation is implicit in the domain name rather than stated, which keeps it just short of a 5.

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

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

The "or get one by NCT id" clause gives a clear conditional for choosing the detail mode over the search mode. It stops short of the highest bar because it never says when not to use this tool, nor whether a search requires at least one filter (all six parameters are optional).

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

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

With no annotations, the description carries the full disclosure burden. It usefully states the source (Companies House advanced search) and the cost ('2 credits'), which is real context an agent cannot get elsewhere. It omits read-only confirmation, result shape, ordering, pagination/limit behavior, and whether exceeding limits truncates or errors.

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 compact fragments, front-loaded with the verb and resource, then filters, then API source, then use case and cost. Nothing is padded, though the sentence-fragment style ('New-business lead lists.') is slightly telegraphic.

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 7-parameter, no-annotation, no-output-schema search tool, the description covers what can be filtered and what it costs but not what comes back (fields, count, ordering) or how the limit interacts with total matches. An agent could invoke it, but not confidently predict or explain the output.

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

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

Schema description coverage is 100%, so the baseline is 3; parameters are already self-documented including the '["active"]' default for status and the 1-100 limit. The description adds meaning only at the aggregate level by naming which filters exist, without clarifying interactions such as whether filters are ANDed or how SIC codes are matched.

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 ('Find') plus the resource ('companies') and enumerates the filter dimensions (incorporation date range, SIC codes, status, location, name fragment), which lets an agent distinguish it from name-lookup siblings like company_search and record-detail siblings like company_profile/company_filings. It falls short of 5 only because no sibling is named directly.

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

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

'New-business lead lists' implies the intended use case, and the filter list hints at what queries belong here. There is no explicit when-not guidance, no mention of when to prefer company_search or company_profile instead, and no prerequisites such as API key or coverage limits.

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

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

With no annotations supplied, the description carries the full burden. It does add genuinely useful behavior beyond the schema by disclosing a cost of 1 credit and implying a read-only historical lookup, but it says nothing about ordering, pagination, or what happens with an invalid or unknown company number.

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 front-loaded sentence naming the resource and its contents, followed by a bracketed cost note. Nothing is wasted, though the cost note could be folded more cleanly and the parenthetical list is dense.

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

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

There is no output schema and no annotations, so the description must cover everything. It does tell the agent what categories of filings come back, but omits result shape, ordering, pagination behavior, and error cases for a tool whose main complexity is the breadth of returned filing data.

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 already documented in the schema. The description reinforces that companyNumber is the key input but adds no format guidance (e.g. with or without leading zeros) and never mentions the limit parameter, so it does not exceed the schema baseline.

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

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

States a specific resource (filing history) keyed on a company number, and enumerates the record types returned (accounts, confirmation statements, officer changes, charges). This distinguishes it reasonably well from siblings like company_officers or company_profile, though it never explicitly says it is the Companies House filing feed, so the agent must infer the jurisdiction.

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: the enumerated record types suggest 'use this when you want the historical filing record rather than current officers or profile data'. There is no explicit when-to-use statement, no mention of alternatives such as company_officers or company_profile, and no prerequisites or failure conditions 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?

No annotations are supplied, so the description carries the full load. It does disclose two genuinely useful behavioral facts an agent cannot get from structured fields: the result content includes appointment and resignation dates, and the call costs 1 credit. It says nothing about pagination, volume of officers returned, or whether historical/resigned officers are included by default.

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

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

One sentence plus a parenthetical cost note, front-loaded with the resource and scoped by the input. Nothing is redundant and the credit cost is placed where it is easy to scan before invocation.

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

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

For a two-parameter read lookup with no output schema and no annotations, the description covers purpose, result content and cost, which is most of what an agent needs. The remaining gap is the semantics of the default active-only filtering, which neither the description nor the schema description text resolves.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents both parameters. The mention of "resignation dates" loosely implies the activeOnly filter's meaning, but the description never explains what activeOnly=false actually changes in the response.

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?

"Directors and secretaries for a company number" states a specific resource and the key input, and the phrase naturally separates it from sibling lookups like company_pscs (persons with significant control) or company_filings. It stops short of naming those siblings explicitly, so an agent must infer the boundary rather than being told 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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives (company_profile, company_pscs, company_filings) that return adjacent company data. The only contextual hint is the implicit prerequisite that a company number is needed, presumably from company_search.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses a cost of 1 credit and enumerates the categories of returned data, including overdue flags, charges, and insolvency flags. However, it does not state error behavior, authentication/rate-limit constraints, or whether missing data is returned as null versus omitted.

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 with the resource and scope front-loaded, followed by the key returned fields and cost. Every element is useful for selection and invocation, with no redundant wording.

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

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

For a one-parameter read lookup with no output schema, the description is largely complete: it defines the resource, lists major returned categories, and discloses the credit cost. It remains slightly incomplete because it omits company-number format expectations and explicit routing guidance among related company tools.

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 single parameter is already documented as a required company number. The description only restates that lookup is by company number and adds no format guidance such as expected length, prefix, or examples. Baseline 3 is appropriate because the schema does the substantive work.

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

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

The description states the specific resource and scope: a full Companies House profile keyed by company number. It enumerates returned data such as status, SIC codes, registered office, accounts dates, charges, and insolvency flags, making the tool's purpose clear. It does not explicitly contrast itself with siblings like company_search, company_filings, or company_officers, so it falls short of a 5.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no named alternatives. An agent can infer that this is for retrieving a company's full profile, but the many related sibling tools are not addressed. It does not mention using company_search first if the company number is unknown.

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

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

No annotations exist, so the description carries the full burden. It does disclose the meaningful behavioral trait of cost ('1 credit') and implies a read-only lookup by asking for a company number, but it says nothing about empty results, invalid-number errors, or whether the data is cached or live.

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 tight sentence with the resource front-loaded and the cost tucked in parentheses. Nothing is wasted and nothing important is buried.

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 lookup with no output schema, the definition is workable but thin: it never indicates what a PSC record contains (names, addresses, nature of control) or how to interpret an empty response. An agent can invoke it, but cannot predict its payload.

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

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

Schema coverage is 100% for the single required parameter, so the baseline is 3. The phrase 'for a company number' maps the input to Companies House-style company numbers, but adds no format, prefix, or validation detail beyond that.

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

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

States the resource precisely and expands the acronym ('Persons with significant control (beneficial owners)'), which makes the tool's data unambiguous. It lacks an explicit verb and doesn't name the sibling it differs from (e.g., company_officers), so it falls 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?

There is no when-to-use or when-not-to-use guidance and no mention of siblings such as company_officers, company_profile, or company_filings that an agent must choose between. The only routing signal is implicit in the resource 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?

With no annotations, the description must carry behavioral disclosure, and it does contribute two real facts: the return shape (number, status, type, incorporation date, address) and the cost of 1 credit. It omits pagination behavior, default limit, and any auth or rate-limit context, so the behavioral picture is only partially filled in.

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

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

Two short sentences, front-loaded with the action and immediately followed by the return fields and cost. No filler, no redundant restatement of the tool name.

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

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

For a two-parameter search tool with no output schema and no annotations, the description adequately covers what it does, what it returns, and what it costs. Minor gaps remain around result limits and how to act on a match, but nothing essential to calling it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (query as required string, limit as number 1-100). The description only adds the semantic that the query is a company name; it says nothing about how limit interacts with results or what happens at the cap.

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

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

States a specific verb and resource ("Search Companies House by name") and names the lookup key, which distinguishes it from profile-style siblings like company_profile and company_filings. It stops short of explicitly naming those siblings, so the differentiation is inferred rather than stated.

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?

"by name" implies you need a company name rather than a company number, which is useful routing context against company_profile. However, there is no explicit when-to-use/when-not guidance, no mention of what to do after finding a match, and no named alternatives among the many company_* siblings.

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

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

No annotations are provided, so the description carries the full burden. It does add a useful non-obvious cost signal (1 credit) and implies a pure read/compute operation, but it says nothing about the return shape (two rendered datetimes? offsets?), DST edge cases, or what happens with an invalid IANA zone.

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

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

Two short sentences, with the action front-loaded and the credit cost appended as a compact parenthetical. Nothing is redundant or 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?

With three parameters, no annotations, and no output schema, the definition should say more about what comes back and how zone/DST errors are handled. The purpose and cost are covered, but an agent cannot fully predict the response from this text alone.

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 IANA zone and ISO 8601 semantics are already documented in the schema. The description only loosely echoes them via "ISO datetime in two time zones" and adds no format examples or constraint details beyond that baseline.

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

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

States a specific verb ("Show") and resource ("an ISO datetime in two time zones"), which is enough to distinguish it from a pure clock lookup. It does not name or contrast with the sibling time_now, so an agent must infer the boundary between 'convert this datetime' and 'get current time'.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as time_now, even though that sibling is the most likely confusion point. The only cue is the implicit framing of converting an existing datetime rather than retrieving the current one.

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

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

With no annotations supplied, the explicit "(cost: 1 credit)" disclosure is valuable behavioral context beyond the schema. However, the description does not address precision or rounding, handling of invalid or incompatible units, or how the converted result is represented.

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 front-loads the operation and supported scope, then states the cost in a compact parenthetical. The category list is substantive rather than filler, and there is no unnecessary wording.

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

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

For a simple three-parameter conversion utility, the scope and cost are sufficient for basic tool selection. Given the generic string parameters and absence of unit enums, annotations, or an output schema, concrete invocation examples and brief error, precision, and result-format details would meaningfully reduce uncertainty.

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

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

Schema description coverage is 100%, establishing a baseline of 3, although those descriptions are minimal. The unit-category list adds some meaning to from and to, but the description provides no accepted unit names or symbol examples and does not explain string values or incompatible unit pairs.

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 verb "Convert" and the enumerated categories clearly state the operation and its scope, including the useful distinction between UK and US volume units. It does not explicitly differentiate itself from related siblings such as convert_time, calculate, or fx_rates.

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 supported-category list provides implicit guidance about when this tool is appropriate. There is no when-not guidance, alternative-tool routing, or clarification of boundary cases such as currency and time-related conversions.

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

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

No annotations are supplied, so the description carries the burden of disclosure. It adds useful cost information and indicates the response includes current ratings, but it does not state read-only behavior, error handling, or auth/rate-limit constraints; for a simple lookup this is adequate but thin.

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 front-loaded sentence plus a cost note, with no filler. It could be slightly more structured, but every element 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 one-parameter lookup, the description covers the resource, identifier, main return content, and cost. It leaves out how to obtain a location id and how this differs from cqc_search, so it is adequate rather than complete.

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

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

The single locationId parameter is fully covered by the schema, so the baseline is 3. The description reinforces that the parameter is a CQC location id but adds no format, validation, or example 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 names a specific resource (CQC location), scope (by location id), and return content (details and current ratings). It is clear enough to distinguish a by-id lookup from a generic search, though it does not explicitly name cqc_search as the alternative.

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

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

There is no explicit when-to-use or when-not-to-use guidance. 'By location id' implies a direct lookup when an ID is known, but it does not tell the agent to use cqc_search first or explain prerequisites.

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

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

With no annotations at all, the description carries the full burden, and it usefully discloses the cost model ("cost: 1 credit"), which is real behavioral information not available elsewhere. However, it says nothing about matching semantics (partial vs. exact, postcode length/format), default result count, or the shape of returned results, which matters for an unannotated 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?

One sentence plus a parenthetical cost note; the resource and lookup keys are front-loaded and there is no filler. Nothing in it could be removed without losing information.

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

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

For a search tool with no output schema and no annotations, the description should at least hint at what comes back (e.g., location IDs usable with cqc_location) and how limit affects credit cost. It covers the search intent adequately but leaves the agent guessing about result contents and follow-up calls.

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

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

Schema coverage is 100%, so baseline is 3, but the schema's parameter descriptions are only type placeholders ("string", "number"), meaning the description is doing most of the real work by labeling name and postcode as the search keys. It adds nothing about the limit parameter (default, max, or interaction with credits), leaving the most ambiguous parameter unexplained.

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

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

The description names a specific verb ("Find") and a concrete resource set ("CQC-registered care homes, GP practices, hospitals and clinics") plus the lookup keys (name or postcode), so an agent immediately knows what the tool returns. It does not distinguish itself from the sibling cqc_location, which likely retrieves details for a single provider, leaving that routing inference to the agent.

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

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

"by name or postcode" implicitly tells the agent this is the entry point when searching for a provider, but there is no explicit when-to-use vs. the cqc_location sibling, no stated prerequisites, and no guidance for what to do when neither key is supplied (0 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?

With no annotations, the description carries the full burden and does add real context: the upstream source (data.police.uk), the spatial radius, the aggregation granularity, and the credit cost. It omits what happens when no crimes are recorded for the point/month, whether coverage is limited to England and Wales, and whether results are anonymised or snapped to approximate locations — meaningful gaps for a data-provenance tool.

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

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

A single dense sentence that front-loads the primary purpose and appends the source, output shape, and cost without wasted words. Every clause carries information an agent needs.

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

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

There is no output schema, so the description must characterize return values, and it does so compactly ('counts by category and a sample'). Given a simple four-parameter lookup, this is close to sufficient; the missing pieces are location-pairing rules and no-data behavior rather than any structural gap.

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

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

Schema coverage is 100%, but the schema descriptions are placeholders ('number', 'string', 'YYYY-MM'), so the description's 'point or postcode' phrasing is what tells the agent that latitude/longitude and postcode are alternative ways to specify the location. It does not state that these are mutually exclusive or that one pair must be supplied, and all four parameters are marked optional with no stated defaults, so the pairing rules remain inferential.

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 (street-level crime), the spatial scope (within about a mile of a point or postcode), the temporal scope (for a month), and the shape of the result (counts by category plus a sample). This is precise enough to separate it from sibling police_neighbourhood, which covers a different granularity, though the description never names that sibling to make the distinction explicit.

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

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

The 'within about a mile of a point or postcode' clause implies when the tool fits, and the '(cost: 2 credits)' note signals it is a paid call worth using deliberately. There is no explicit when-to-use, when-not-to-use, or alternative routing (e.g., to police_neighbourhood or geocode) guidance.

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

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

With no annotations, the description carries the full burden and discloses only the 1-credit cost. It does not state read-only behavior, what happens for an unknown or malformed DOI, whether the call fails or returns an empty payload, or any rate limits.

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

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

Two short fragments with no wasted words, but the brevity comes at the cost of under-specification rather than disciplined concision. The cost note is front-loaded well but sits alongside a bare noun phrase rather than a complete statement of action.

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

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

For a tool with no annotations and no output schema, the description should say what metadata is returned (title, authors, citation counts?) and how failures surface. Neither is covered, so an agent knows the input but not what it will get back or how errors behave.

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

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

Schema coverage is 100%, so the single 'doi' parameter is technically documented, but the schema text is only 'string, required'. The description adds that the value must be a DOI resolvable via Crossref, which is a marginal but real clarification 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 fragment 'Metadata for a DOI from Crossref' identifies the resource and data source, but relies on the tool name for the verb 'lookup'. It does not explicitly contrast itself with siblings like papers_search or arxiv_search, which an agent might reasonably pick for a similar metadata-fetching task.

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

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

No when-to-use guidance is given: nothing says to call this only when a DOI is already known, or to use one of the search siblings when only a title/author is available. The credit cost note hints at frugality but is not usage direction.

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

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

With no annotations, the description bears the full behavioural burden. It usefully discloses the transport (DNS over HTTPS) and the cost (1 credit), which are genuine additions. However, it does not say what happens for a non-existent domain, whether missing record types cause an error or are omitted, or whether SPF/DMARC are parsed from TXT records — meaningful gaps for a network lookup tool.

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

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

One front-loaded sentence stating the record types and mechanism, plus a parenthetical cost note. There is no redundant or filler wording, and the most decision-relevant information comes first.

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

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

For a one-parameter read-only lookup this is close to sufficient, but with no output schema the agent gets no hint about the return shape — whether records are grouped by type, raw strings, or absent when not configured. That omission matters because SPF and DMARC results differ structurally from A/MX records.

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

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

Schema coverage is 100%, so the single 'domain' parameter is documented structurally, and the description's phrase 'for a domain' adds no syntax or format detail (e.g., no subdomain, trailing-dot or IDN guidance). With one parameter and full schema coverage, 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 concrete resource (specific DNS record types — A, AAAA, MX, NS, SPF, DMARC) and the lookup mechanism (DNS over HTTPS) for a domain. This clearly separates it from nearby siblings like ssl_check, rdap_lookup and ip_lookup, which examine different artefacts. It lacks an explicit verb such as 'look up' or 'retrieve', but the intent 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?

There is no when-to-use guidance and no mention of alternatives, despite adjacent tools (ssl_check, rdap_lookup, ip_lookup, email_check) that an agent could plausibly confuse with this one. The only contextual cue is the credit cost, which is budgeting information rather than selection guidance.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two genuinely useful and non-obvious facts: no email is actually sent (so the agent knows this is passive) and the call costs 1 credit. It says nothing about latency/DNS dependence, caching, or whether results are authoritative.

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 front-loaded sentence with the tool's distinctive checks first, the critical scope caveat second, and cost last. No filler words and nothing an agent must skip over.

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, annotation-free, output-schema-free tool this is close to sufficient: the checks listed implicitly describe what the answer will report. It would be complete with one clause on the response shape (e.g. per-check booleans plus MX hosts), since no output schema exists to fall back on.

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

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

Schema coverage is 100%, so the baseline is 3, and the schema's own text ('string, required') is thin. The description only adds that the value is 'an email address', which the schema name already implies; it gives no format examples or normalization behavior (e.g. case folding, trimming).

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 (an email address) and enumerates the exact checks performed: syntax, MX, disposable, role and free-provider. The parenthetical 'no message is sent' removes ambiguity with any send-email tool, and the resource makes it trivially distinguishable from validators like iban_validate or domain_check. It stops short of a 5 only because no sibling is ever named explicitly.

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

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

Usage is implied by the verb 'check' on an email address, which an agent will read as pre-validation before storing or contacting an address. There is no explicit when-to-use, no when-not-to-use, and no named alternative among the many validator siblings (iban_validate, domain_check, ip_lookup). 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?

With no annotations, the description carries the full burden; it usefully discloses the credit cost (1 credit) and the fields returned, which is real added value. It does not say whether a lookup without postcode/address is valid, whether multiple certificates can be returned, or how limit behaves.

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 front-loaded sentence with the resource first, the lookup keys second, and the cost last; nothing is redundant. The fragment style omits a verb, which is minor but keeps it tight.

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

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

For a 3-parameter tool with no annotations and no output schema, the description covers what data comes back and the cost, which is most of what an agent needs. It leaves the optional-parameter semantics (no required fields) and result-set behavior unaddressed, which is a meaningful gap for a search tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description names the two lookup parameters but adds no format details (e.g. postcode normalization) and never mentions limit, so it adds little meaning beyond the schema.

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

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

Names a specific resource (Domestic Energy Performance Certificates) plus the lookup keys (postcode or address) and the data returned (ratings, efficiency, property type, floor area). The sibling price_paid covers a different dataset, so confusion risk is low, though no explicit differentiation is stated.

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

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

The phrase 'by postcode or address' implies how to invoke it, but there is no statement of when to prefer this tool, no exclusions, and no note that at least one of postcode/address should be supplied despite both being optional in the schema.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only discloses the credit cost. It does not state whether the operation is read-only (though 'Search' implies it), what permissions or authentication are required, how results are paginated, or what happens when the query matches nothing.

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 front-loaded sentence with no wasted wording. The cost note is compact and directly relevant to invocation decisions.

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

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

With no annotations, no output schema, and three parameters whose schema descriptions are uninformative, the description should do more. It omits result format, pagination behavior, date-window semantics, and any guidance on parameter interaction, leaving significant gaps for an agent trying to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the schema descriptions themselves are nearly meaningless ('number', 'string, required'). The description adds no meaning about what query searches, what units daysBack uses, or what limit controls.

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 (Search), resource (EU public procurement notices), source (TED), and method (full text), so the agent knows exactly what the tool retrieves. It does not explicitly distinguish itself from the sibling tools, but those cover unrelated domains (SEC filings and World Bank), making 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?

The description implies this is the tool for full-text searches of EU procurement notices, but it offers no when-to-use guidance, no conditions under which to prefer alternatives, and no mention of how daysBack or limit should shape usage. The agent must infer all invocation context.

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

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

With no annotations, the description carries the full behavioral burden. The credit-cost note is a genuinely useful disclosure, but nothing is said about matching behaviour (exact vs fuzzy name search), result caps or pagination, or error behaviour when the register has no match. It also doesn't clarify whether the search returns full authorisation detail or just identifiers.

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 what is searched and what it returns conceptually, with the cost tacked on in parentheses. Nothing is wasted, though the parenthetical cost would read better as a structured field than as trailing prose.

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?

This is a simple two-parameter read-only search with a fully described schema and no output schema, so the description is broadly sufficient to call it. It remains thin on result shape and matching semantics, which matter for an agent deciding whether a search hit is authoritative.

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

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

Schema coverage is 100%, so the schema already documents both parameters and the baseline is 3. The description's "firms or individuals" loosely mirrors the type enum, but it adds no syntax, format, or matching guidance for the query string beyond what the schema states.

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 ("Search") and resource ("FCA Financial Services Register") and scopes it to "authorised firms or individuals," which implies the type parameter. It does not explicitly differentiate itself from look-alike siblings such as company_search or company_profile, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. An agent must infer from the purpose sentence alone that this is the tool for UK financial-regulator authorisation checks, and must guess whether it also covers e.g. company-house style lookups.

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

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

With no annotations, the description carries the full burden, and it does disclose two real traits: the data is 'live' (not cached/archival) and each call costs 1 credit. It says nothing about authentication, rate limits, result ordering, or what a warning record contains, which is a meaningful gap for an unannotated tool.

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

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

A single front-loaded sentence with the resource stated first and the cost annotation appended in parentheses; nothing is wasted. It is arguably too terse rather than bloated, but there is no filler to cut.

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

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

For an unannotated, no-output-schema tool, the definition should describe the shape of a result (severity levels, affected areas, timestamps) and what limit does. Those are absent, leaving the agent to guess at return content and the meaning of the severity scale beyond the bare '1-4' in the 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 nominally 100%, but the schema descriptions are placeholders ('number', 'string', 'number 1-4'), so the schema adds little meaning. The description clarifies that county is an optional geographic filter and that minSeverity is a 1-4 scale via the schema, but 'limit' is left entirely unexplained.

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

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

States a specific resource (Environment Agency flood warnings and alerts) plus scope (optionally by county), which is far more informative than the bare name. It is implicitly distinct from siblings like weather or food_alerts, but never explicitly contrasts itself with weather, so it falls short of the sibling-differentiation bar for a 5.

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

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

There is no when-to-use guidance and no mention of alternatives such as weather for general forecasts. The phrase 'optionally by county' hints at filtering but does not tell the agent when to supply a county versus omit it, or when this tool is preferred over a general weather lookup.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the 1-credit cost and implies recency via 'Latest,' but does not explain auth needs, pagination, default result count, or response shape.

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 definition is a single, front-loaded sentence with no filler, and the cost note is compact. It is appropriately sized for a simple retrieval tool, though the parenthetical cost could be integrated more naturally.

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 tool with one optional parameter and no output schema, the description covers the core resource and cost. However, it leaves gaps around result ordering, default count, and what a returned alert contains.

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 optional 'limit' parameter is already described in the schema as 'number 1-100.' The description adds no additional meaning about the limit or its defaults, 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?

The description clearly identifies the resource as 'Latest Food Standards Agency product recalls and allergy alerts,' so an agent knows what data it retrieves. It does not explicitly distinguish the tool from siblings, though the sibling list contains no comparable food-alert 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?

There is no stated guidance on when to use this tool, when not to use it, or which alternatives to prefer. The intended use is only implied by the resource 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?

With no annotations, the description carries the full burden; it does disclose the credit cost and the returned fields (rating, scores, address, phone, coordinates), which is genuine behavioral context. It omits pagination behavior for the limit parameter, whether all filters combine or AND, and any coverage/jurisdiction note (FSA implies UK only, which is left implicit).

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

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

Two sentences, zero filler, front-loaded with the source and resource followed by filters, returns, and cost. Every clause earns its place.

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

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

For a 9-parameter, all-optional search with no output schema, the description usefully substitutes for the missing return documentation by listing what comes back and noting the cost. Gaps remain around how the ID-based filters are sourced and whether filters combine, but nothing critical to 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 baseline is 3. The description adds limited meaning beyond the schema: it signals that 'radius' works together with coordinates and that 'rating' and 'council' map to specific filters, but it does not explain the rating code format or how businessTypeId/localAuthorityId values are obtained.

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 ('search food businesses') and enumerates the filter dimensions (name, address, council, type, rating, radius), which is enough to separate it from siblings like food_alerts or cqc_search. It stops short of explicitly naming what it is not, so it does not reach the top band.

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?

Listing the searchable filter dimensions implicitly tells an agent how the tool is used, but there is no statement of when to choose it over alternatives (e.g., food_alerts for recalls) and no exclusions or prerequisites. 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the 1-credit cost and the formatting modes, but it does not describe error behavior, whether currency conversion is performed, or what the output looks like.

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

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

The description is a single front-loaded sentence plus a short cost note. Every element is relevant and there is no unnecessary wording.

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

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

The tool is simple and the schema covers all parameters, but with no output schema the description should ideally state what formatting result is returned. It also mentions compact form even though no such parameter exists in the schema, which leaves a small completeness gap.

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

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

Schema description coverage is 100%, so the schema already documents amount, locale, currency, and words. The description adds a use case for words (cheques and contracts), but it also mentions a compact form that is not represented in the schema, leaving some ambiguity without adding deeper meaning to the documented parameters.

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

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

The description states a specific verb and resource: formatting a money amount with currency, locale, compact form, and optional words. It is clear what the tool does, but it does not distinguish itself from nearby siblings such as calculate, convert_units, or fx_rates by explaining why an agent should choose this formatter over those tools.

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

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

The description gives an implied use case for the words option, noting it is for cheques and contracts, and mentions compact form. However, it does not state when to use this tool rather than currency-conversion or calculation siblings, nor does it give explicit exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden, and it does disclose useful non-schema facts: the data source (ECB reference data) and a cost of 1 credit. It does not say what the response contains, whether rates are ECB-daily (so non-business days may fall back), or what errors look like for bad dates/currencies.

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

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

A single sentence that front-loads the resource and source, then the supported knobs, with the cost tucked into a short parenthetical. Nothing is wasted, though the parenthetical credit note slightly interrupts the parameter list.

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

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

For a 4-parameter, zero-required, no-output-schema tool with no annotations, the description covers source, scope and cost but omits the return shape and edge-case behavior — both of which the agent must guess absent an output schema. Adequate but not complete.

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

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

Schema description coverage is 100%, so the baseline is 3; the description only restates that base, symbols and amount are optional and that any base works. It leaves the effect of 'amount' unexplained — whether it returns a converted value or a rate table — which is the one piece of meaning the schema does not convey.

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

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

The description names a specific resource (ECB reference exchange rates) and enumerates the supported variations: latest or a given date, any base, optional symbols and amount. It is unambiguous and clearly distinct from the time/holiday siblings, though it never explicitly contrasts itself with them (the domains differ enough that this is minor).

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 'latest or a date' and by calling out which fields are optional, so an agent can infer the normal call pattern. There is no explicit guidance on when to prefer this over another tool, what happens with an invalid date or unsupported symbol, or any prerequisite, so it stays at minimum-viable.

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

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

With no annotations supplied, the description carries the full burden, and it does disclose two useful traits: the data source (OS Open Names) and the per-call cost of 1 credit. It omits behavioral details that matter here — how ambiguous names are resolved, whether multiple matches are returned, and geographic coverage limits — so the disclosure is partial.

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

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

A single compact sentence that front-loads the input→output mapping, with the dataset and cost parentheticals trailing where they belong. No wasted words, though the compression is telegraphic enough that a little more structure would help.

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

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

There is no output schema, so the description must convey return values — it does list coordinates, county, district, and region, which is the minimum needed. It does not explain the coordinate format, how results are ordered when 'count' > 1, or failure behavior for unknown names, leaving gaps for a 2-parameter lookup tool.

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

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

Schema description coverage is 100%, so 'query' and 'count' (number 1-20) are already documented in the schema. The description adds no syntax, format, or matching-behavior detail for either parameter, 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?

Names a specific transformation (GB place name → coordinates, county, district, region) and cites the underlying dataset (OS Open Names), which is far more than a restatement of the name. It does not, however, differentiate itself from the obvious sibling postcode_lookup, which an agent could easily confuse it with for UK location resolution.

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

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

There is no statement of when to use this versus postcode_lookup or wikidata_lookup, no note that it only covers Great Britain (so non-GB queries will fail), and no guidance on what to do when a place name is ambiguous. The agent must infer all selection logic.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses that the return is 'clean text' and that the call costs 1 credit, which is useful, but omits behavior on invalid paths, truncation (implied by maxChars), and whether the leading slash is required.

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 front-loaded sentence plus a parenthetical cost note, with zero wasted words. The example path and credit cost both earn their 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 simple two-parameter fetch tool with no output schema, the description is adequate but leaves gaps: it doesn't explain what 'clean' means, how maxChars affects the return, or error behavior. Combined with the absence of annotations, more disclosure would help an agent invoke it correctly.

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

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

Schema description coverage is 100%, so the schema itself is the baseline for parameter meaning. The description adds a concrete path example (/vat-rates) that clarifies format, but leaves maxChars semantics (truncation? character count?) unexplained beyond the bare schema.

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

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

The description states a specific verb ('Clean text of') and resource ('a GOV.UK page') and gives a concrete example path (/vat-rates), which lets an agent distinguish this fetch-a-page tool from search-style siblings like govuk_search. It doesn't explicitly name the sibling alternative, so it falls short of a 5.

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

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

'by path (e.g. /vat-rates)' weakly implies this is used when you already know a path, but there is no explicit when-to-use guidance, no when-not-to-use, and no reference to govuk_search as the alternative for discovering paths.

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

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

With no annotations, the description carries the entire behavioral burden. It discloses only the cost ('1 credit'), which is genuinely useful, but says nothing about result format, ordering/relevance, truncation behavior, or permissions, leaving the agent to discover these empirically.

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 clauses, front-loaded with the purpose and the action; the cost note is separated in parentheses. There is no wasted wording, though one more sentence of routing guidance would have been a better use of space than nothing.

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 search tool with full schema coverage and no output schema, the definition is minimally adequate. It omits result shape and ranking behavior, which an agent calling a search endpoint would reasonably want to know.

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 the query and limit parameters (with its 1-50 range) are documented structurally. The description adds no syntax or query-language guidance 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 verb ('Search') and a named resource scope ('GOV.UK guidance, news and publications'), which lets an agent distinguish it from legislation_search and petitions_search. However, it never explicitly contrasts with the closest sibling govuk_page (fetching a known page), so the differentiation is inferred rather than stated.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative. An agent must guess that govuk_page is for retrieving a known page and this tool for discovery, and nothing addresses edge cases such as when to prefer legislation_search for statutory material.

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

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

No annotations are supplied, so the description must carry the behavioral burden. It usefully discloses a per-call cost of 1 credit, which is meaningful operational context, but it says nothing about result format, pagination, default limit, or which mode wins when both kind and query are supplied.

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 front-loaded sentence covering both browse and search modes plus the cost, with no filler. Every clause carries information the agent needs.

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

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

For a simple three-parameter read tool with no output schema this is close to adequate, but the missing default-limit behavior and the unresolved overlap with the news_search sibling leave real gaps an agent would want filled.

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 three parameters and their constraints (kind values, limit 1-50, query string). The description adds only the surface-level meaning of the keyword search and does not clarify interactions between kind and query or the default limit.

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

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

The description names the resource (Hacker News stories) and the exact operating modes (top, new, best, or keyword search), so an agent knows precisely what it returns. It does not explicitly differentiate itself from the sibling news_search, which appears to overlap on keyword search, leaving slight ambiguity about source coverage.

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: pick a feed kind for browsing, or pass a keyword to search. There is no explicit when-not or guidance on choosing between this and the sibling news_search or rss_read, so an agent must infer the routing decision itself.

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

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

With no annotations, the description carries the full burden. It usefully discloses two traits: the cost per call and the fact that a UUID is appended, which implies the output is non-reproducible across identical inputs. It omits what the returned structure looks like, which algorithm is used when the optional parameter is omitted, and any limits on input size.

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

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

One front-loaded sentence plus a parenthetical cost note, with no filler. It could be marginally sharper by stating the default algorithm in the same breath, but nothing present is wasted.

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

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

For a two-parameter, non-destructive utility with no output schema, the description covers purpose, output composition, and price, which is close to sufficient. The gaps are the unspecified default algorithm and the undisclosed return format, both of which an agent would need before relying on the output.

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

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

Schema description coverage is 100%, so both the text input and the SHA-1/SHA-256/SHA-384/SHA-512 enumeration are fully documented structurally, making 3 the baseline. The description adds only the general notion of SHA hashing and no per-parameter meaning, so it neither compensates for nor extends 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?

"SHA hash of text plus a fresh UUID" states a specific operation and resource, and the UUID detail meaningfully differentiates its output from adjacent text utilities like text_stats. It is clear enough that an agent can pick it over the listed siblings without opening the schema, though it never names a sibling explicitly.

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

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

There is no guidance on when to choose this tool, no prerequisites, and no mention of alternatives among the seven sibling utilities. The only contextual remark is a billing note ("cost: 1 credit"), which does not help an agent decide whether to invoke it.

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

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

With no annotations at all, the description carries the full disclosure burden, and it does add real value by stating the data source (HMRC) and the cost ('1 credit'), which is a behavioral trait an agent otherwise could not know. It does not say what happens if the optional month is omitted (assume latest month?), how far back history goes, or what the rate payload looks like. Useful, but incomplete for an unannotated tool.

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

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

A single tightly written clause covering resource, source, scope, and cost, with no filler. The credit cost is appended in parentheses rather than front-loaded, but everything present 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?

The tool is simple (one optional string parameter, no output schema), so the bar is low, and the description covers source, scope, and cost. The main omission is default behavior when month is absent, which is exactly the ambiguity an agent faces with an optional-only parameter set and no annotations to fall back on.

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 'month' is documented as 'YYYY-MM', so the schema already carries the semantics. The description's word 'monthly' reinforces the granularity but adds no format, defaulting, or range information 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 names a specific resource with source and scope: 'HMRC monthly exchange rates for customs and VAT, every currency to GBP.' An agent immediately knows what data comes back (monthly HMRC rates quoted against GBP). It stops short of naming the sibling it differs from (fx_rates, boe_series), so the distinction is inferable from the 'HMRC/customs/VAT' qualifier rather than stated.

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?

'for customs and VAT' hints at the use case, implying this is the authoritative rate set for HMRC filings rather than a generic market rate feed. However, it never states when to prefer this over fx_rates or boe_series, and gives no prerequisites or exclusions. Usage is implied, not guided.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavior: the operation costs 1 credit. However, it does not state what is returned, and it is silent on the notable fact that all three inputs are optional (what happens if only daysPerWeek or only hoursPerWeek is passed, or none at all).

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 front-loaded clause plus a parenthetical cost note, with no filler. The trade-off is that the brevity leaves the usage and return-value gaps unfilled, but nothing written is wasted.

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

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

For a three-parameter calculation tool with no output schema and no annotations, the description should say what the result looks like (entitlement in days or hours) and how the optional inputs combine. Neither is covered, so an agent cannot predict the response shape or the default behavior when parameters are omitted.

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 nominally 100%, but the schema text is near-contentless ('number', 'number 0-12'), so the baseline of 3 applies rather than a penalty. The description's phrase 'working pattern, pro rata by months' is the only thing signalling that daysPerWeek/hoursPerWeek are alternative ways to express the pattern and monthsWorked drives proration.

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 (statutory paid holiday entitlement) and its calculation basis (working pattern, pro rata by months), which separates it from sibling calendar tools like bank_holidays, public_holidays and working_days. The verb is only implied ('for a working pattern'), but the resource and scope are unambiguous.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternative is named despite several adjacent holiday/days siblings. An agent must infer that this computes entitlement rather than listing holidays, and gets no hint about which of the optional inputs to supply.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits: the 1-credit cost and the shape of the returned data (price, index, annual change). It says nothing about whether the call is read-only (inferable from the resource), error behaviour for an unrecognised slug, or how the 'latest' month is determined.

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 tightly packed sentence with the resource, measures, granularity and scope front-loaded, followed by slug examples and the cost. No filler, nothing repeated from the schema.

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

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

For a simple two-parameter read tool with no output schema, the description is close to sufficient: it states what comes back, what geography means, and the cost. The remaining gap is the semantics of 'months' (window size, ordering, default when omitted).

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 nominally 100%, but the schema text is effectively empty ('string', 'number 1-120'), so the description does real work by explaining that 'area' is a slug and giving three concrete examples at different geographic levels. It leaves 'months' unexplained beyond the schema's 1-120 range, so it does not fully compensate for both parameters.

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

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

The description names the specific dataset (UK HPI) and the three returned measures (average price, index, annual change), with the granularity (by month) and the geographic scope (country, region or local authority). This separates it from siblings such as price_paid or ons_timeseries, 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 implied by the geographic scope and slug examples, making it obvious this is the tool for UK house price statistics. There is no explicit when-to-use guidance, no statement of when to prefer price_paid or ons_timeseries, and no mention of data lag or coverage limits.

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

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

With no annotations, the description carries the full burden; it does disclose the specific checks performed (length, structure, mod-97) and the billing cost of 1 credit, which are genuinely useful behavioral facts. However it says nothing about what is returned, what happens for a malformed or invalid IBAN, or whether failures raise errors versus a validity flag — significant omissions for a validation tool with no output schema.

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

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

A single front-loaded sentence conveys both modes, the checks performed, and the split-out behavior, with the cost tacked on compactly in parentheses. No sentence is wasted and the mode distinction is signposted by the "or".

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

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

For a 3-parameter tool with no annotations and no output schema, the description should explain the return shape (valid/invalid plus parsed sort code and account) and the input-combination rule. It covers the input side and cost but leaves the output contract entirely unspecified, so an agent cannot anticipate the response.

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 nominally 100%, but every parameter is described only as "string", so the schema conveys no meaning; the description compensates partially by mapping sortCode/accountNumber to the UK format-check mode and iban to full validation. It still gives no format expectations (country prefix, length, digit-only sort code) that would prevent malformed calls, so this sits at the baseline rather than above it.

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

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

States a specific verb and resource ("Validate an IBAN") and enumerates exactly what is checked — length, structure, mod-97 check digits — plus the secondary extraction mode and the alternate UK sort code/account mode. No sibling in the list does IBAN or sort code validation, so an agent can place it unambiguously.

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 "or" construction makes clear there are two operating modes and which inputs belong to each, giving contextual guidance without explicit exclusions. It stops short of stating the crucial rule that an agent must supply either iban OR sortCode+accountNumber (the schema marks zero required params), leaving the mutual-exclusivity condition implicit.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the credit cost of 1, which is genuinely useful, but says nothing about whether this is a pure generator or has side effects, what happens when optional fields like end or timezone are omitted, or how the result is returned. For a 6-parameter tool with zero annotation coverage, that is a substantial gap.

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

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

Two short clauses, front-loaded with the purpose and followed by the cost note; there is no filler. It is arguably under-specified rather than verbose, which is a completeness problem rather than a conciseness one.

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

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

For a tool with 6 parameters, no annotations, no output schema, and non-trivial datetime/timezone semantics, the description is too thin. It never explains the return value, whether end is required in practice (schema marks nothing required despite "required" in the start/title descriptions), or how timezone affects the output.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema with its type and format hints (ISO datetime, IANA). The description adds no further meaning, no defaults, no interaction notes between start/end/timezone. 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?

The description states a specific verb and resource: "Build an .ics calendar event." An agent immediately knows this generates iCalendar data rather than performing a lookup or transformation. It does not need to distinguish itself from siblings (hash_text, qr_code, ssl_check, etc.), which are unrelated utilities, so the only gap is that it never says what the output is (presumably an .ics string).

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

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

There is no when-to-use or when-not-to-use guidance, and no prerequisites or alternatives are named. The usage is strongly implied by the verb "Build," but the description does nothing to confirm the intended context (e.g., that this is for exporting a single event rather than a full calendar).

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

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

With no annotations supplied, the description carries the full burden; it does disclose two useful behavioral traits — a 2-credit cost and newest-first ordering — that are not in the schema. However, it does not state what happens when 'query' is omitted (all three parameters are optional), what the result records contain, or any pagination/volume limits. That leaves significant behavioral gaps for a zero-annotation tool.

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

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

A single front-loaded sentence plus a cost parenthetical — every element (source, notice types, match mode, ordering, price) adds information and there is no filler. Nothing is buried or redundant.

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

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

For a three-optional-parameter, no-output-schema, no-annotation tool, the description should explain default behavior when no filters are supplied and roughly what a notice record looks like. It covers cost and ordering but leaves those gaps, making it only adequate.

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

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

Schema description coverage is 100%, so the schema already documents 'days', 'limit' and 'query' including their ranges. The description only adds that matching is free-text ('query') and that results are ordered newest-first, which loosely relates to 'days' but gives no default or interaction detail. Baseline 3 is appropriate.

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

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

The description names the specific source and resource (Gazette insolvency notices) and enumerates the covered notice types (winding up, administration, liquidation, bankruptcy), which clearly separates it from generic siblings like company_filings or news_search. It also establishes retrieval mode ('by free text') and ordering ('newest first'), though it never uses an explicit verb like 'search' or 'list'.

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

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

There is no when-to-use guidance at all: nothing says to pick this over company_search, company_filings, or legislation_search when investigating a distressed company, and no exclusions are given. The only implied usage comes from the enumerated notice types.

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

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

With no annotations supplied, the description carries the full burden, and it does add two genuinely non-obvious facts: the data source (RDAP) and a cost of 1 credit. It says nothing about behavior for malformed or private/reserved IPs, IPv4 vs IPv6 support, rate limits, or failure modes, so the mutation/safety profile is only partially covered.

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

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

One front-loaded clause naming the question and the returned fields, followed by a compact parenthetical for cost. Nothing is wasted and the most decision-relevant information comes first.

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

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

For a single-parameter lookup with no output schema and no annotations, the description does well to enumerate the return fields, which substitutes for the missing output schema. However it leaves open input format and error behavior, which matters for an agent that must decide whether an arbitrary string is a valid argument.

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 nominally 100%, but the only parameter is documented as 'string, required', which conveys no real meaning, so the description must carry the load. It does establish that the parameter is an IP address, but adds no format expectations (dotted-quad vs CIDR vs IPv6) beyond that, so the baseline 3 applies rather than more.

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

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

States a specific resource (an IP address) and the question answered (ownership), plus the concrete fields returned (network name, range, country, organisations). It is clear what the tool does, but it does not differentiate itself from the sibling rdap_lookup, which the parenthetical '(RDAP)' actually makes look redundant.

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

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

There is no when-to-use or when-not-to-use guidance, and no pointer to alternatives such as rdap_lookup, domain_check, or ssl_check, which an agent could easily confuse with this tool. The agent has to infer applicability purely from the noun phrase 'IP address'.

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

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

With no annotations, the description carries the full burden. It usefully discloses the supported schema keyword subset (type, required, properties, items, enum, min/max, pattern) and a cost of 1 credit, which is real behavioral context. However it never says what happens on invalid JSON, whether failures raise errors or return a validity result, or what the response contains.

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 compact sentence with the core action front-loaded and the cost note appended. Nothing is redundant, though the keyword list is dense and could have been separated 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?

For a validation tool with no output schema and no annotations, the description should explain the shape of a validation result (valid flag vs. error list). It covers input-side scope well but leaves the output contract and failure behavior unspecified.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some meaning by clarifying that the schema argument is a 'simple JSON Schema' restricted to specific keywords, but it does not resolve the schema's own inconsistency (both params typed as string with vague descriptions like 'object').

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 pair (parse and validate) and the resource being validated (JSON against a JSON Schema), which is unambiguous. No sibling tool in the list does anything similar, so no differentiation is required.

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

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

There is no explicit when-to-use or when-not-to-use guidance, but the parenthetical keyword list implicitly scopes the tool to 'simple' schemas and signals that unsupported constructs are out of scope. An agent can infer usage but must guess at edge cases.

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

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

With no annotations, the description carries the full disclosure burden. It does add real behavioral context that structured fields lack — the base-rate-plus-8% calculation basis and a 1-credit cost — but it says nothing about the tiered fixed compensation amounts, the treatment of a missing paidDate, or the shape of the result, and there is no output schema to fall back on.

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 clauses with zero waste; the domain and the formula are front-loaded, and the cost note is placed last where it belongs. It is lean to the point of being sparse, which is penalized under completeness rather than here.

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

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

For a four-parameter financial calculation with no annotations and no output schema, the description leaves key questions unanswered: whether paidDate is optional and what that implies, which jurisdiction/statute applies, and what the response contains. The formula and cost are the only completeness wins.

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

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

Schema description coverage is 100%, so the baseline is 3. The parenthetical '(base rate plus 8%)' indirectly explains what baseRateOverride replaces (the statutory base rate), which is a small genuine addition, but dueDate, paidDate and invoiceAmount semantics come entirely from 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?

Names the specific resource and computation (statutory interest plus fixed compensation on a late commercial invoice) and even states the formula, so an agent can distinguish it from generic siblings like calculate, statutory_sick_pay or redundancy_pay. It stops short of naming an alternative tool or an explicit verb, but the domain is unmistakable.

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

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

There is no when-to-use or when-not-to-use guidance and no prerequisites: it never says this applies to UK commercial (B2B) invoices, nor what happens if paidDate is omitted (accrual to today). The agent must infer the applicability from the title alone.

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

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

With no annotations, the description carries the full burden. It usefully discloses the credit cost (1 credit) and the title-only matching behavior, but says nothing about result format, pagination, ordering, or whether the operation is read-only (implied by 'search' but unstated).

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

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

Two short clauses, front-loaded with the core purpose and the cost caveat. No wasted words, though the parenthetical domain and cost could be structured more cleanly as separate sentences.

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 full schema coverage, the description covers the essentials. It falls short on what results look like, how 'title' matching behaves (exact vs partial), and how this differs from the sibling legislation_text tool.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema (query as required string, limit as number 1-50). The description adds only the notion that 'query' matches against legislation titles; it adds nothing about limit's range or behavior. 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 ('Search UK legislation') plus a scoping constraint ('by title') and the data source (legislation.gov.uk). This implicitly separates it from the sibling legislation_text, which presumably retrieves full text, though that sibling is never named.

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

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

No when-to-use or when-not-to-use guidance, and no alternatives named. The phrase 'by title' hints that this is a title lookup rather than a full-text search, but an agent must infer whether to call this or legislation_text. No prerequisites or follow-up guidance is given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses a cost of 2 credits, but does not explain return format, authentication needs, rate limits, truncation behavior for maxChars, or what happens when an invalid URL is supplied.

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

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

The description is a single compact sentence plus a cost note, with the resource and scope front-loaded. It is efficient, though the parenthetical cost feels slightly detached from the main usage description.

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-style tool with no output schema, the description covers the core purpose and cost, but leaves gaps around return format, section behavior, and maxChars truncation. It is minimum viable rather than fully complete.

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

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

Schema coverage is 100%, so all three parameters are already documented in the schema. The description adds only mild meaning by indicating that the section parameter retrieves one section, while maxChars and URL format expectations are not elaborated 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 and operation: retrieving the text of an Act, instrument, or one section from a legislation.gov.uk URL. It clearly distinguishes the tool from search-oriented siblings by requiring a URL, though it does not name legislation_search explicitly.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative is named. The URL-based phrasing implies this is a follow-up to a search tool, but the agent must infer that relationship.

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

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

No annotations exist, so the description carries the full burden; it does contribute real context by disclosing the data source (GLEIF) and the cost of one credit, which matters for agent budgeting. It says nothing about match behavior (exact vs fuzzy name matching), what is returned when no entity is found, or pagination/rate limits. Safe read-only nature is only inferred from the verb 'Find'.

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

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

One dense sentence, front-loaded with the verb and lookup keys, followed by the payoff fields and a cost note. There is no filler and every clause adds 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 five parameters, no annotations, and no output schema, the description does useful work by enumerating the returned attributes, which substitutes for the missing output schema. However, it leaves the most consequential gaps for a multi-key lookup: which key to prefer, how name matching behaves, and what limit does remain unaddressed.

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

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

Schema description coverage is nominally 100%, but the schema entries are bare type names ('string', 'number', 'ISO2'), so the schema itself conveys little meaning. The description adds the mapping 'by LEI or name' and mentions 'direct and ultimate parent', which hints at the parents flag, but limit, country, and the boolean default are not elaborated. Baseline 3 fits given the coverage figure.

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

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

The description states a specific verb and resource ('Find a legal entity'), names the authoritative source (GLEIF) and the two lookup keys (LEI or name), plus the returned fields. It is clearly distinguishable from siblings like company_search or wikidata_lookup by virtue of the LEI/GLEIF framing. It stops short of explicitly contrasting itself with those siblings.

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

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

Usage is only implied by the phrase 'by LEI or name' — there is no statement of when an agent should choose this over company_search, company_profile, or wikidata_lookup, nor any when-not guidance. Nothing explains what happens when neither key is supplied, even though zero parameters are required.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a genuinely useful behavioral fact not available elsewhere in the definition — that the call costs 0 credits — and implicitly that it is a cheap read. However, it omits pagination, ordering, and whether the list is scoped to the caller's own imported APIs.

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

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

Two short sentences, front-loaded with the verb and resource, which is the right structure for a trivial listing tool. "Free. (cost: 0 credit)" states the same fact twice, which is mild waste in an otherwise tight definition.

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

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

For a zero-parameter listing tool this is close to adequate, and with no output schema the description does attempt to characterise the return values ("with operation counts"). It nonetheless leaves the shape of an API entry and the scope of "imported" unexplained, which is the remaining gap an agent would hit on first 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?

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. The input schema is empty and fully consistent with the description's silence on arguments.

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

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

States a specific verb and resource ("List imported APIs") plus the content of each entry ("with operation counts"), so the agent knows it retrieves a catalogue rather than performing a lookup like the sibling arxiv_search or weather. The qualifier "imported" is left undefined, leaving ambiguity about which APIs appear in the list, and no sibling is named as a contrast.

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

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

There is no statement of when to call this versus anything else, no prerequisites, and no exclusions. The only decision-helping content is the cost note, which hints it is safe to call freely but says nothing about the appropriate context or what the caller should do with the result.

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

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

No annotations are supplied, so the description carries the full burden. It does disclose two useful behaviors (UTF-8 with BOM, Excel-safe) and a cost of 1 credit, but it omits what the tool actually returns (file path, URL, or attachment), where the file is written, and what happens when filename is omitted.

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 front-loaded clause plus a parenthetical cost note – no waste. However, it is compressed to the point of being a fragment rather than a sentence, which slightly hurts 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?

With no annotations and no output schema, the description must explain the return value and file destination, and it does neither. For a file-producing tool, the agent cannot tell whether it gets a path, a download URL, or inline content after calling it.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the meaningful detail that rows may be an array of objects (implying header derivation), but this actually conflicts with the schema, which types rows as an array of strings or a bare string; filename is left entirely unexplained beyond its 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?

The description names the conversion (array data to a CSV file) and the output format, which distinguishes it from the make_xlsx, make_docx, and make_print_html siblings. The phrasing is telegraphic (no explicit verb such as 'Convert'), but the resource and result are unambiguous.

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

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

There is no when-to-use guidance: it doesn't say to prefer make_xlsx for a spreadsheet, or make_print_html for printable output, nor when CSV is the right choice. No prerequisites or constraints 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?

With no annotations, the description still adds real value: it discloses the return shape (a download URL, or base64 when storage is disabled) and the cost of 3 credits. It does not cover failure modes, input size limits, or any auth/rate-limit considerations, which leaves meaningful gaps for a no-annotation tool.

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

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

Two compact sentences: the operation leads, the return/cost detail follows. Nothing is wasted and nothing important is buried.

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

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

No output schema exists, and the description competently explains what comes back (URL or base64). For a three-parameter converter this is nearly sufficient; only edge-case behavior such as size limits or error handling is absent.

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 three parameters are structurally documented and the baseline of 3 applies. The description adds no meaning about title vs filename behavior or which fields are required (the schema text is only the placeholder 'string'), so it neither compensates nor misleads.

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?

"Markdown ... to a Word .docx file" states a specific transformation and target format, so the agent can tell it apart from make_csv, make_xlsx and make_print_html by output type. It stops short of naming those siblings explicitly, so it is clear but not fully differentiated in prose.

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

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

There is no when-to-use or when-not-to-use guidance; the agent must infer that this is the right tool purely from the word '.docx'. The obvious alternatives in the sibling list (make_xlsx, make_csv, make_print_html) are never mentioned, so routing between converters is left entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses a cost of 1 credit and that output is 'standalone' (self-contained), but says nothing about whether the HTML is returned inline or as a file, styling/CSS handling, size limits, or required permissions.

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 front-loaded sentence identifies source, output, and purpose, with the cost parenthetical appended. There is no filler and nothing important is buried.

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, no-output-schema tool this covers the essential purpose, but it leaves open what the caller actually receives (HTML string vs file reference) and how markdown formatting maps to print styling. Adequate rather than complete.

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

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

Schema coverage is nominally 100%, so the baseline is 3, but the schema descriptions are placeholders ('string', 'string, required') and the description adds no meaning about what `title` does or how it affects the printed document. It neither helps nor harms relative to 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 conversion (Markdown → print-ready standalone HTML) and names the intended end use (PDF printing), which implicitly distinguishes it from the make_docx/make_xlsx/make_csv siblings. It does not explicitly name an alternative, so it stops short of a 5.

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

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

The phrase 'for PDF printing' implies the scenario in which this tool is the right pick, but there is no explicit when-to-use versus when-not or a named alternative for non-print outputs. Guidance is only implied.

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

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

With no annotations, the description carries the burden but does disclose two useful behaviors: the output is a download URL and the call costs 3 credits. It omits what happens to existing files, whether the URL expires, and whether rows and sheets are mutually exclusive, which matters for a write/creation tool.

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

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

One compact sentence with the essential action front-loaded and the cost appended in parentheses; nothing is wasted. The wording is slightly telegraphic ('Rows ... to an Excel .xlsx file'), which keeps it from a 5.

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

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

For a 4-parameter, all-optional creation tool with no annotations and no output schema, the description covers the core action and return value but leaves defaults, parameter interplay, and failure modes unexplained. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The phrase 'Rows (or several named sheets)' adds a little meaning by implying the rows and sheets parameters are alternate input modes, but it does not clarify filename defaults or which parameter wins when both are supplied.

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

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

The description names a concrete transformation (rows/sheets → .xlsx file) and states the return artifact (a download URL), so an agent can tell this builds a spreadsheet rather than reading one like the sibling read_spreadsheet. It does not explicitly name the sibling distinction, keeping it below a 5.

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

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

There is no explicit guidance on when to use this versus read_spreadsheet or pdf_to_text, and no note about when not to use it. The only contextual hint is the word 'make' implying creation, which the agent must infer from the name and siblings.

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

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

With no annotations, the description carries the full behavioral burden, and it usefully discloses a per-call cost of 1 credit. It does not disclose authorization requirements, whether the name search is exact or fuzzy, pagination behavior tied to the limit parameter, or the shape of results.

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

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

A single front-loaded sentence covering both modes plus the cost; there is no filler or redundancy to trim.

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 three-parameter lookup tool with no output schema, the description covers purpose, both search modes, and credit cost adequately. The remaining gaps, notably limit semantics and no-result behavior, are modest but real.

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 nominally 100%, but the schema descriptions are placeholders that merely restate the type, so the description is the only source of meaning. It clarifies the roles of postcode and name but says nothing about limit, which is left entirely undefined.

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 ("Find the MP for a postcode", "search current MPs and peers by name") and covers both operating modes. It is clearly distinguishable from the sibling tools (petitions, legislation, food alerts), though it does not explicitly contrast itself with any of 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?

The description implicitly pairs each input with a mode: postcode for MP lookup, name for searching MPs and peers. There is no guidance on when to prefer one mode, what happens if both are supplied or neither is given, or what to do when no match is found.

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

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

No annotations are supplied, so the description carries the full disclosure burden. It usefully reveals the GDELT origin and the per-call cost of 1 credit, which is genuinely non-obvious behavioral context. It says nothing about result volume limits, ranking, pagination, or failure modes on empty/oversized windows.

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

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

Two short clauses and a cost note, with the capability stated first and the constraint and cost trailing. Every element carries information; nothing is padded.

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

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

For a four-parameter search tool with no annotations and no output schema, the definition covers what it searches and the cost but omits return shape, ordering, and result-cap behavior. An agent can invoke it, but cannot predict what comes back.

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

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

Schema coverage is 100%, so the baseline is 3. The description does clarify that `hours` is a lookback window and `country` filters by source country, which resolves ambiguity in bare "number 1-720" schemas, but `query` receives no explanation at all — including how it interacts with the other filters.

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 ("Search") and resource ("global online news"), plus the upstream data source (GDELT) and a time-window scope. It is clearly distinguishable from siblings hacker_news and rss_read by resource type, though it never names or contrasts them explicitly.

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

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

There is no when-to-use or when-not-to-use guidance, and neither sibling (hacker_news, rss_read) is mentioned as an alternative. The only implied routing signal is that this tool is for recency-bounded news queries, which an agent must infer on its own.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the data source (ODS directory) and a cost of 1 credit, which is real operational context. It does not say whether the call is read-only (implied), whether results are paginated, what the default result count is, or what happens when all filters are omitted.

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 front-loaded sentence with the resource first and the qualifiers after; the credit cost is tucked into parentheses so it doesn't obstruct scanning. No filler, though the fragmentary construction (no leading verb) slightly weakens immediate legibility.

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 four-optional-parameter lookup tool with no annotations and no output schema, the description covers what the tool is and where the data comes from. It leaves gaps an agent would care about: default behaviour with zero parameters, expected result volume, and response shape.

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

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

Schema description coverage is nominally 100%, but the schema descriptions are bare type stubs ('string', 'number'), so the baseline of 3 applies. The description confirms name, postcode and role as search dimensions, which helps map intent to parameters, but adds nothing about the 'limit' parameter or about partial-match vs exact-match behaviour for name/postcode.

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

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

The description names the resource precisely — NHS organisations from the ODS directory — and enumerates the entity subtypes (trusts, GP practices, pharmacies, hospitals) plus lookup keys (name, postcode, role). The verb is only implied (a noun phrase rather than 'Search...'), but the intent is unambiguous and clearly distinguishable from siblings like cqc_search or postcode_lookup.

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

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

Usage is implied rather than stated: an agent can infer this is the tool for finding NHS bodies by name/postcode/role. However, there is no explicit when-to-use guidance, no mention of how it differs from cqc_search, cqc_location, or postcode_lookup, and no statement about combining or prioritising the filters.

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

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

No annotations are supplied, so the description carries the full disclosure burden, and it adds only a credit cost ('cost: 1 credit'), which is genuinely useful. It says nothing about what a search returns (datasets vs. bulletins vs. series records), pagination, result ranking, or whether the cost is per call or per result, which matters for a metered tool.

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

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

Two short clauses, front-loaded with the action and the resource, with the cost tucked in a parenthetical. Nothing is wasted, though the brevity is close to under-specification rather than disciplined economy.

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 metered, annotation-free search tool with no output schema, an agent still cannot tell what a result record looks like, how to page through results, or why it should pick this over 'ons_timeseries'. The description is complete enough to attempt a call but not enough to call it correctly the first time.

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% ('query' as required string, 'limit' as number 1-50), so the schema already documents both parameters. The description adds no meaning beyond that, but the baseline of 3 applies 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?

The description gives a specific verb ('Search') and names the concrete resource domain ('ONS datasets, bulletins and time series'), so an agent knows this queries UK Office for National Statistics content. It falls short of a 5 because it never distinguishes itself from the sibling 'ons_timeseries', even though it explicitly claims to cover time series, leaving ambiguity about which tool handles series data.

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

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

There is no guidance on when to use this versus the obvious alternative, 'ons_timeseries', or versus generic search siblings like 'govuk_search' or 'news_search'. Usage is only implied by the word 'Search', and no exclusions, prerequisites, or selection criteria are stated.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses a cost of 1 credit and implies a read-style observation lookup, but says nothing about return shape, pagination, default dataset/frequency behavior, error handling, or rate limits beyond the single-credit cost.

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 front-loaded sentence with useful examples and a clear cost note. There is no filler or redundant wording.

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

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

For a four-parameter data retrieval tool with no annotations and no output schema, the description is too thin. It omits defaults for dataset and frequency, limit behavior, and the relationship to ons_search for finding valid CDIDs.

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

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

Schema description coverage is 100%, so all four parameters are at least nominally documented in the schema. The description adds helpful CDID examples, but does not explain the meaning or behavior of dataset, frequency, or limit beyond the terse schema text.

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: observations for an ONS time series by CDID, with concrete CDID examples such as D7G7 and MGSX. It is clear what the tool retrieves, though it does not explicitly distinguish itself from the sibling ons_search 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 phrase 'by CDID' and the examples imply the tool is for cases where the series identifier is already known. However, it gives no explicit guidance on using ons_search to discover a CDID first, and no when-not-to-use or alternative 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?

With no annotations supplied, the description carries the full behavioral burden but does disclose two useful facts: the upstream source (deps.dev) and the cost (1 credit). It is silent on whether the call is read-only, what happens for an unknown package name, whether a 404 is returned or an empty result, and any rate limiting — gaps that matter for unannotated tools.

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 tight sentence, front-loaded with the most salient output field and ending with source and cost. No filler. It would read slightly better as a verb phrase ('Get latest version …') to make the action explicit, but nothing is wasted.

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

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

For a 2-parameter lookup with no output schema, the enumeration of return fields is genuinely useful as a de-facto output description. However, required-parameter semantics remain ambiguous (schema declares zero required while 'name' is annotated 'string, required'), and failure behavior for unknown packages is unaddressed, leaving the definition under-complete for its simplicity level.

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 documented in the schema, including the ecosystem value set (npm|pypi|cargo|go|maven|nuget|rubygems). The description adds nothing about parameter meaning, default ecosystem behavior, or whether name must be qualified — baseline 3 is the correct ceiling given the schema already does the work.

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

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

The description names the exact resource ('a package') and enumerates the fields returned (latest version, publish date, deprecation, licences, advisories, links), plus the data source (deps.dev). An agent knows immediately this is a package metadata lookup. It falls short of 5 because it never distinguishes itself from adjacent siblings such as vuln_check, which also covers advisories.

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

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

There is no when-to-use or when-not-to-use guidance, and no named alternative is offered for overlapping needs (e.g. vuln_check for security-only queries, product_recalls for a different domain). Usage is only inferable from the field list, which is weaker than explicit 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?

With no annotations, the description carries the full burden. It does disclose two things structured data does not: the credit cost (1 credit) and the shape of the returned fields, which is meaningful for a paid call. It says nothing about result ordering, pagination/total counts, rate limits, or error behavior, so the mutation/consumption profile is only partially covered.

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

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

Two compact clauses, front-loaded with the action and resource, then return fields, then cost. No filler or restatement 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?

For a 4-parameter read tool with no output schema and no annotations, enumerating the returned fields plus the credit cost covers most of what an agent needs to decide and call. The remaining gap is behavioral detail around result limits and source-specific differences, which the description leaves entirely implicit.

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

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

Schema description coverage is 100%, so all four parameters are already documented, making 3 the baseline. The description adds one genuinely new fact not in the schema: that source defaults to OpenAlex. It adds nothing about limit's interaction with totals or the year-range 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?

States a specific verb+resource ("Search scholarly papers") and enumerates what comes back (authors, venue, year, DOI, citations, open-access link), plus the two underlying sources. It does not name or contrast with any sibling (arxiv_search, pubmed_search, doi_lookup), so the agent must infer the boundary itself.

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 only usage signal is that OpenAlex is the default and Crossref is the alternative source. There is no statement of when to pick this over arxiv_search, pubmed_search, or doi_lookup, and no exclusions or prerequisites.

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