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

No annotations are provided, so the description carries full behavioral burden. It discloses nothing about return volume, pagination, hierarchy flattening, or whether level/parent_code constrain the output. For a zero-annotation read tool with two undocumented optional filters, this 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?

It is one terse line with no waste, but the brevity reflects under-specification rather than efficient front-loading. Adding route information while omitting purpose is a poor use of the little space there is.

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

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

A zero-annotation, zero-schema-coverage tool with no output schema leaves the entire specification burden on the description, which provides almost none of it. For a hierarchical index with two filter parameters, this is inadequate.

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

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

Schema coverage is 0% and the description adds nothing about 'level' or 'parent_code'. An agent cannot know what values level accepts (e.g., numeric depth, enum) or what parent_code references. The description completely fails to compensate for the coverage gap.

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

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

The description 'SBI code index' restates the tool name and adds only the HTTP route. It identifies the resource (SBI codes, a Dutch business classification index), but the verb/purpose is unclear—is it listing, fetching, or indexing? It does not distinguish itself from getapi_cbs_sbi_search or getapi_cbs_sbi_detail.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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. The tool does not state whether it's an unfiltered dump/index vs. filtered retrieval, nor does it point to the sibling getapi_cbs_sbi_search for search or getapi_cbs_sbi_detail for detail. The agent must guess which of the three SBI tools to call.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the HTTP method and path. It says nothing about read-only semantics (implied by GET but not stated), error behavior for unknown codes, 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?

Very short and front-loaded with no wasted words, but the brevity reflects under-specification rather than disciplined concision. The bracketed endpoint is the only structural element.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 an undocumented parameter, the definition is not complete enough for an agent to invoke the tool confidently or interpret a result. A sentence on the code format and the returned SBI record would close the 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 0% for the single required 'code' parameter, so the description must compensate. It never explains what an SBI code is, its expected format, or whether the lookup is exact-match, leaving the parameter undefined beyond its name.

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

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

States a recognizable verb+resource ('SBI code lookup') and the endpoint path with a {code} path parameter, which implies a single-record detail fetch. However, it does not distinguish itself from close siblings like getapi_cbs_sbi_search or getapi_cbs_sbi, so an agent cannot tell which to pick without guessing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, no mention of when not to use it, and no reference to the sibling lookup/search tools. The only routing hint is the {code} path shape, which is inferential 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 supplied, so the description carries the full behavioral burden, yet it says nothing beyond 'search'. The GET path weakly implies a read-only operation, but there is no disclosure of pagination, rate limits, matching semantics (exact vs partial), or what happens when q 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?

It is a single short line with no wasted words and the bracket endpoint reference is compact. The brevity is really under-specification rather than tight editing, so it is appropriately sized but not informative.

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

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

With no annotations, no output schema, 0% parameter documentation, and two sibling tools covering the same SBI domain, the description does not supply enough for an agent to call this tool correctly or choose it over alternatives. It is essentially a name restatement plus a URL.

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

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

Schema description coverage is 0%: both parameters are undocumented, and the schema even leaves 'limit' with no type or constraints. The description adds nothing about what 'q' should contain (SBI code fragment? description text? min length 2) or what 'limit' controls, so an agent has no basis for filling them correctly.

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

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

The description pairs a verb ('search') with a resource ('SBI code') and names the HTTP endpoint, so the general function is inferable. However, it does not explain what an SBI code is or how this differs from the sibling getapi_cbs_sbi and getapi_cbs_sbi_detail, leaving the agent to guess which of the three to pick.

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

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

There is no statement of when to use this tool versus the closely related getapi_cbs_sbi and getapi_cbs_sbi_detail siblings, no prerequisites, and no mention of result limits or filtering behavior. The endpoint path is the only context provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: the 'GET' marker at least implies a read-only operation, but there is no word on pagination, result limits, geographic scoping rules, or what happens when no location parameters 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?

One short phrase plus an endpoint tag. It is brief, but this is under-specification rather than conciseness — nothing here earns its place beyond the endpoint string, which is arguably metadata rather than 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 4-parameter tool with zero schema coverage, no annotations, and no output schema, the description supplies essentially no information an agent needs. Nothing covers parameter meaning, geographic scoping, or return 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 0% and the description names no parameters at all. The four undocumented parameters (lat, lon, postcode, huisnummer) are self-evident in Dutch only if the agent knows the domain; the description adds no meaning, no units/format, and no indication of whether they combine or are alternatives.

Input schemas describe structure but not intent. Descriptions should explain 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 ('zoeken') and resource ('Omgevingsdocumenten'), and the bracketed 'GET /v1/dso/documents' pins the endpoint. However, it does not differentiate from the sibling getapi_dso_plans, which also appears to deal with DSO documents, so an agent cannot tell them apart from the text alone.

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

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

No when-to-use guidance, no prerequisites, and no mention of the alternative getapi_dso_plans or any of the location-lookup siblings. The agent is left to infer that this is a location/address-scoped document 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, yet it discloses almost nothing. The inline '[GET /v1/dso/plans]' implies a read-only search, but there is no mention of pagination, result limits, required auth, or what happens with partial/missing query inputs.

Agents need to know what a tool does to the 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 phrase with no filler, which is genuinely concise. But its brevity reflects under-specification rather than disciplined economy, so it earns only a middle score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 description omits parameter meaning, return shape, and invocation guidance. Only the endpoint path adds information beyond the tool name, leaving the definition materially incomplete.

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

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

Four parameters (lat, lon, postcode, huisnummer) have zero schema description coverage and the description says nothing about them. An agent cannot tell whether these are alternative addressing modes, whether one is required, or what format each expects.

Input schemas describe structure but not intent. Descriptions should explain 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 clear verb and resource ('Ruimtelijke plannen zoeken' = search spatial plans) plus the concrete endpoint GET /v1/dso/plans, so an agent understands the operation. However, it does nothing to distinguish this from a sibling like getapi_dso_documents, which serves the same DSO domain.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 mention of prerequisites, and no pointer to alternative tools for spatial-plan vs document lookups. The agent must infer usage entirely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. The bracketed '[GET /v1/kadaster/bag/address]' hints at a read-only GET, but nothing states auth requirements, rate limits, error behavior, or what the response contains (no output schema exists).

Agents need to know what a tool does to the 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 that states the operation and its key inputs, with the endpoint in a compact bracket. Efficient, though the path bracket is somewhat redundant for an agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 0% schema coverage across 4 parameters, a single sentence is insufficient. An agent cannot tell what the return payload looks like, how optional parameters narrow results, or how this differs from the suggest/id siblings.

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

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

Schema description coverage is 0% and the schema itself is bare (house_letter and house_number_addition have no type at all). The description names only the two required inputs and says nothing about the optional house letter/addition parameters that refine an address match, so half the parameters remain 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?

States a specific verb and resource ('Address lookup') and names the two key inputs (postcode, house number), so the operation is immediately clear. It does not, however, distinguish this exact lookup from the closely-related sibling getapi_kadaster_bag_address-suggest (autocomplete) or getapi_kadaster_bag_id, leaving overlap unresolved.

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

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

There is no guidance on when to use this tool rather than the sibling suggest endpoint or the id endpoint, nor any note on prerequisites or exclusivity. The agent must infer usage purely from the name and the two named 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?

No annotations are supplied, so the description carries the full behavioral burden. It discloses only the HTTP method (GET, implying read-only) via the endpoint string, and says nothing about rate limits, result count defaults, or what happens with unmatched 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?

A single short line with the purpose front-loaded. The inline endpoint is redundant with the tool name's implied route, but it costs little and does confirm the method.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 GET with no output schema, the description still leaves the meaning of both parameters, the expected result shape, and the autocomplete context unstated. It is too thin to invoke correctly without guessing.

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

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

Schema description coverage is 0% and the description adds nothing about either parameter. The 2-100 character constraint on 'q' and the untyped 'limit' are left entirely undocumented, including the fact that 'q' is the partial address fragment to complete.

Input schemas describe structure but not intent. Descriptions should explain 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 operation (autocomplete suggestions) on a specific resource (address), and the bracketed endpoint confirms it is the suggestion endpoint rather than the full address lookup. It is distinguishable from siblings like getapi_kadaster_bag_address, though it never says so 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 statement of when to use autocomplete suggestions versus the full address lookup or the id lookup, both of which are siblings. An agent must infer the use case purely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only lookup via the 'lookup' verb and GET path, but discloses nothing about return shape, error behavior on an unknown/invalid ID, or whether data is cached or rate-limited.

Agents need to know what a tool does to the 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 named first, plus the endpoint annotation. No filler, though the endpoint suffix is arguably redundant with 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 trivial one-parameter read tool with no output schema, the minimum is arguably met. But with zero annotations and zero param descriptions, the definition leaves the agent without return-value expectations or sibling routing, which is a real 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 0%, but the schema's pattern (^[0-9]{16}$) carries the format. The description does add real meaning by identifying the id as a 'nummeraanduiding ID', which the bare schema does not say; it stops short of explaining the identifier's origin or valid sourcing.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Address lookup') and the key type ('nummeraanduiding ID'), which distinguishes it from the string-based getapi_kadaster_bag_address sibling. However, it never explicitly contrasts itself with that sibling, so 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?

No when-to-use guidance, no prerequisites, and no mention of the closely related getapi_kadaster_bag_address / getapi_kadaster_bag_address-suggest siblings. An agent must guess which lookup variant fits the input it holds.

Agents often have multiple tools that could apply. Explicit usage 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 states neither authentication requirements, rate limits, whether the optional VIES validation triggers external calls, nor what the 'basisprofiel' response contains. Only the endpoint string discloses that it is a read by 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 compact fragment with the resource identified first and the endpoint appended. It wastes no words, though its brevity reflects under-specification rather than disciplined editing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 must explain what a 'basisprofiel' returns and how it differs from the branch and search siblings. It omits this entirely, leaving the agent unable to judge fit or expected output for a tool with three parameters.

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

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

Schema coverage is 67%: the vat/vies aliases are described in the schema, but the required companyNumber parameter has no schema description. The description contributes nothing beyond echoing the path template {companyNumber} and adds no meaning to the optional VAT/VIES validation parameter.

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

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

The description names the resource (KVK detail / basisprofiel) and the endpoint GET /v1/kvk/{companyNumber}, so the operation is identifiable. However, 'detail' is generic and it does nothing to distinguish itself from the nearby sibling getapi_kvk_detail_branch or clarify the relationship to getapi_kvk_search. Adequate but with a clear differentiation gap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 tool versus getapi_kvk_search or getapi_kvk_detail_branch, and no mention of prerequisites (e.g., needing a valid companyNumber from a search). Only the implicit GET semantics hint at read usage.

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

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

No annotations are provided, so the description carries the full behavioral burden. It reveals only that this is a GET (read) operation via the endpoint path; it says nothing about authentication requirements, rate limits, error behavior when a companyNumber has no branches, or how the branch data relates to the parent company. This is far short of what a no-annotation tool 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?

The definition is extremely short and front-loaded, but that brevity reflects under-specification rather than efficient communication. Nothing is padded, yet almost every sentence that would earn its place (purpose detail, parameter meaning) is absent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 0% parameter description coverage across two parameters, the description is the only information source and is inadequate. An agent cannot confidently invoke this tool correctly or interpret its branch-level scope from the single phrase provided.

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

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

Schema description coverage is 0%, so both parameters are undocumented in structured form. The description's path template hints that companyNumber is the required identifier, but it never explains what it is (KVK number format) and does not mention the optional 'vestigingsnummer' at all, leaving a documented parameter 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?

The phrase 'KVK vestigingsprofiel' identifies the resource (a branch/location profile from the KVK registry) and the tmp endpoint path implies a retrieval, so the agent can infer roughly what the tool returns. However, it is a bare noun phrase with no verb, and it never distinguishes itself from the sibling 'getapi_kvk_detail' (company-level detail) or explains what a 'vestigingsprofiel' contains versus that sibling.

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

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

There is no when-to-use guidance, no stated prerequisites (e.g., needing a valid companyNumber or vestigingsnummer), and no reference to alternative tools such as getapi_kvk_detail or getapi_kvk_search. The agent must guess when this branch endpoint is preferred over the company detail endpoint.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, yet it only gives a purpose and an endpoint hint. It says nothing about authentication requirements, rate limits, pagination, or what the search returns, leaving a significant 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 short sentence with the endpoint reference is efficiently front-loaded and wastes no words. It is arguably too terse, but there is no bloat or redundancy, which is what this dimension measures.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 annotations and no output schema, the description is incomplete: it never indicates how results are retrieved, what they contain, or how the empty parameter set is meant to function. An agent cannot confidently invoke a 'search' with no criteria 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?

The tool takes zero parameters, so the baseline is 4. The description correctly adds nothing to clarify, since there is no schema detail to compensate for. The notable oddity of a 'search' with no query parameters is not addressed, but no parameter semantics are required.

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

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

States a clear verb and resource: 'Zoeken in KVK Handelsregister' (Search in the KVK Trade Register), reinforced by the 'search' name and the [GET /v1/kvk/search] endpoint hint. It does not explicitly distinguish itself from the sibling getapi_kvk_detail / getapi_kvk_detail_branch, though the verb does implicitly differentiate search from detail 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?

The description offers no guidance on when to use this tool versus alternatives like getapi_kvk_detail or getapi_kvk_detail_branch. There is no mention of context, prerequisites, or exclusions beyond the bare purpose statement.

Agents often have multiple tools that could apply. Explicit usage 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. 'Lookup' implies a read-only query, but the description says nothing about authentication, rate limits, or what the response contains. For a network-facing DNS tool with zero annotation coverage, this is a notable 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?

One short sentence plus the endpoint path, front-loaded with the core operation. There is no wasted text, though the bracket notation is redundant with 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 simple one-parameter lookup this covers the essentials, but with no output schema, no annotations, and no parameter documentation, an agent learns nothing about the return shape or the expected domain input format. Minimally viable 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 parameter 'domain' has 0% schema description coverage and no constraints documented in the schema beyond maxLength. The description only echoes that the lookup is 'for a domain', adding no format, normalization, or validation detail that would help an agent construct the value correctly.

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

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

The description states a specific operation and resource: a nameserver lookup for a domain, with the HTTP endpoint as supporting detail. It is nearly distinguishable from the sibling getapi_lookup_dns_records, but does not explicitly say how it differs (nameservers vs. general DNS records), leaving that distinction to inference.

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

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

There is no guidance on when to use this tool versus the closely related getapi_lookup_dns_records or any other lookup sibling. No prerequisites, no conditions, no exclusions 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?

With no annotations, the description carries the full behavioral burden and discloses almost nothing: no rate limits, no auth requirements, no indication of what happens with type=ALL versus a specific type, and no note on caching or error behavior. For a read-only lookup this is a notable gap, though the operation is inherently low-risk.

Agents need to know what a tool does to the 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 HTTP route bracketed at the end. No wasted words, though the route annotation is thin padding for an agent that needs behavioral detail instead.

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

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

For a two-parameter lookup with no output schema and no annotations, the description should at least clarify the type enum's role (especially ALL) and what the response contains. As written, an agent must infer the entire contract from the schema 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 0%, so the description must compensate, yet it only loosely names 'domain and record type' without explaining the enum values (A, AAAA, MX, ALL, etc.), the default when type is omitted, or the 253-character domain limit. It adds partial meaning but leaves the enum discovery entirely 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?

The description states a specific verb (lookup) and resource (DNS records) scoped to a domain and record type, so the agent knows exactly what the call returns. It does not, however, distinguish itself from the sibling getapi_lookup_dns_nameservers, which is a closely related concept an agent could easily confuse.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 getapi_lookup_dns_nameservers or getapi_lookup_ip, no prerequisites, and no indication of when a lookup would fail (e.g., invalid domain). The GET route is the only contextual hint.

Agents often have multiple tools that could apply. Explicit usage 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 and no output schema, the description carries the full behavioral burden and largely drops it. The only behavioral signal is the embedded '[GET /v1/lookup/ip]' tag, which implies a read-only call; there is no mention of rate limits, auth requirements, error behavior for malformed/private IPs, 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 tight sentence with the endpoint tag appended; nothing is padded. It is front-loaded with the verb and resource, though the bracket tag is somewhat mechanical.

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

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

For a one-parameter read tool with no output schema, the description gives a partial sense of the return payload ('ISP information and location details') but omits parameter format constraints and any behavioral notes. It is minimally viable 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 description coverage is 0% and there is one required parameter, so the description must compensate. It only restates 'for an IP address', adding no format detail (IPv4 vs IPv6, CIDR support, whether hostnames are accepted), which is the main ambiguity for this parameter.

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

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

States a specific verb ('Get') and a specific resource ('ISP information and location details for an IP address'), which cleanly distinguishes it from sibling lookups like getapi_lookup_dns_records, getapi_lookup_postcode, and getapi_lookup_dns_nameservers. It stops short of explicitly naming alternatives, but the resource itself is unambiguous.

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

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

The description says what the tool returns but never states when to reach for it versus the other lookup/validation siblings, nor any prerequisites (e.g., that an IP must be public, or what to use for domain/DNS lookups instead). No exclusions or context are offered.

Agents often have multiple tools that could apply. Explicit usage 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. The bracketed '/GET /v1/lookup/postcode' implies a read-only operation, but nothing is said about authentication, rate limits, response shape, or what a missing/invalid postcode yields.

Agents need to know what a tool does to the 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 short line with the resource and endpoint front-loaded; no filler. It is under-specified rather than bloated, which the other dimensions already penalize.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 two parameters at 0% schema coverage, the description is too thin. An agent cannot tell what 'number' does or what the lookup returns, so it is not complete enough to call the tool confidently.

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

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

Schema description coverage is 0% and the description adds nothing: 'number' is an untyped empty schema (presumably a house number) and its role is never explained, nor is the required postcode format. The description merely echoes the resource name, so it does not compensate for the low coverage.

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

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

States a specific verb (lookup) and resource (postcode) scoped to the Netherlands, which is enough to separate it from the DNS, IBAN, KVK and BAG siblings. However, it never says what the postcode resolves to (street, address, coordinates), so the purpose is clear but shallow.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 tool versus alternatives such as getapi_kadaster_bag_address or getapi_kadaster_bag_address-suggest, and no prerequisites or exclusions. The agent must infer usage entirely from the 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?

No annotations are provided, so the description carries the full burden. The bracketed '[GET /v1/ndw/emissiezones]' at least implies a safe read-only HTTP call, but nothing is said about pagination behavior, result shape, rate limits, or required auth, which matters for a 4-parameter list endpoint.

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

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

The single line is compact and front-loads the resource name, so it is not bloated. But its brevity stems from omission rather than disciplined editing, and the raw endpoint bracket adds little value beyond what the name already conveys.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four undocumented parameters, no annotations, and no output schema, the description is far too thin. It gives no indication of filtering semantics, pagination, or response content, so an agent cannot reliably call it without experimentation.

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

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

Schema description coverage is 0% across four parameters (city, page, per_page, zone_type), and the description provides no explanation of any of them. The agent must guess what units page/per_page use, how city is matched, and what the zone_type enum values imply.

Input schemas describe structure but not intent. Descriptions should explain 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 Dutch phrase 'Emissiezones lijst' does convey a verb (list) and resource (emission zones), so an agent can infer the tool returns a list of emission zones. However, it is essentially a restatement of the tool name (which already contains 'emissiezones') plus the raw HTTP route, and it draws no distinction from siblings like getapi_ndw_laadpunten or getapi_ndw_truckparking.

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

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

There is no guidance on when to use this tool, what filters are meaningful, or how it relates to the other NDW endpoints. The agent gets no context for choosing between this and similar list endpoints.

Agents often have multiple tools that could apply. Explicit usage 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, and it adds nothing: no statement of pagination behavior, default page size, result volume, or auth requirements. The GET path hints at a read, but the description itself is behaviorally silent.

Agents need to know what a tool does to the 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 fragment is short and front-loaded, but brevity here is under-specification rather than economy: nothing in the single phrase conveys actionable information beyond the tool name and the raw endpoint.

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

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

For a 6-parameter query tool with no annotations and no output schema, the description supplies no filtering semantics, no pagination model, and no return-shape hints. An agent cannot reliably construct a correct call from this definition.

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

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

Six parameters at 0% schema description coverage (city, page, status, per_page, beschikbaar, connector_types[]), and the description explains none of them. It does not state what 'beschikbaar' means, the status values, or the connector_types array format, so it fully fails to compensate for the coverage gap.

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

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

The description names the resource ('Laadpunten' = charging points) and the HTTP endpoint implies a list operation, so the intent is inferable. However it is a bare Dutch noun phrase with no verb, no scope statement, and no differentiation from the related NDW siblings (getapi_ndw_emissiezones, getapi_ndw_truckparking).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 mention of filtering intent, pagination expectation, or when to prefer a sibling tool. The agent must guess entirely from 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 provided, the description carries the full burden of behavioral disclosure, yet it only embeds "GET" in the endpoint path, which weakly implies a read-only retrieval. It says nothing about pagination, filtering behavior, authentication, or the shape of results for a 5-parameter list endpoint.

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

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

The text is short, but this is under-specification rather than conciseness — a single fragment that spends its few words restating the name and endpoint instead of conveying anything 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?

A five-parameter tool with no annotations, no output schema, and 0% schema coverage receives essentially no supporting context. Nothing in the definition tells an agent how to invoke it correctly or what to expect back.

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

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

Schema description coverage is 0% and the description adds no parameter meaning whatsoever. Five parameters (page, road, status, per_page, beschikbaar) are left completely undocumented, including the ambiguous Dutch field "beschikbaar" and the pagination pair.

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

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

"Truckparking lijst" is essentially a Dutch restatement of the tool name plus the raw endpoint path, with no verb or scope added. It does signal that the tool returns a list of truck parking locations, but that much is already inferable from the name, so it reads as a tautology rather than a purpose statement.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 indication of when to call this tool, what it is useful for, or how it relates to siblings such as getapi_ndw_emissiezones or getapi_ndw_laadpunten. An agent must infer usage entirely from the 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 behavioral burden and discloses almost nothing beyond the HTTP GET endpoint. It does not state authentication needs, rate limits, error behavior for invalid addresses, or what the response contains; only the GET method implies read-only.

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

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

The description is a single front-loaded phrase with no filler, which is efficient. However, its extreme brevity leaves gaps that a slightly expanded definition could have filled without becoming verbose.

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

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

Given four parameters at 0% description coverage, no annotations, and no output schema, the one-line description is far too thin. It omits required parameter semantics, return values, and behavioral context that an agent would need to invoke the tool correctly.

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

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

Schema description coverage is 0% across four parameters, and the description only says 'Dutch address' without mapping any meaning to zipcode, house_number, house_letter, or house_number_addition. It does not compensate for the undocumented schema fields at all.

Input schemas describe structure but not intent. Descriptions should explain 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 ('lookup') and resource ('energy label') scoped to a Dutch address. It is immediately distinguishable from sibling tools like getapi_property_pandgegevens or getapi_lookup_postcode by its unique energy-label subject.

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

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

The description implies usage through 'Dutch address' but gives no explicit when-to-use guidance, no prerequisites, and no alternative tools for related property lookups. An agent must infer all routing decisions from the purpose 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no authentication requirement, no indication whether every pandgegevens record is returned or whether some addresses yield empty results, no error semantics, no rate-limit note. For an external lookup API with zero structured coverage this is a serious 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?

It is a single short, front-loaded line with no wasted words and it usefully carries the endpoint path. The brevity, however, reflects under-specification rather than disciplined concision.

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

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

A four-parameter external property lookup with no annotations and no output schema needs the description to explain inputs, expected results, and error/empty-result behavior. None of that is present, so an agent cannot call this tool confidently.

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

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

Four parameters with 0% schema description coverage and no annotations, yet the description mentions none of them. The untyped house_letter and house_number_addition fields (no type, no description) are completely unexplained, and the required postcode/house_number pairing is only discoverable 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?

The description essentially restates the tool name plus the HTTP path: "Property data lookup (pandgegevens) [GET /v1/property/pandgegevens]". It adds almost nothing about scope, what data is returned, or how it differs from the sibling getapi_property_pandgegevens-lite, which is never mentioned.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 prerequisites, and no routing to the -lite variant or to getapi_kadaster_bag_address, which covers overlapping Dutch address/property data. The agent is left to infer usage entirely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It reveals only that this is a GET lookup returning 'property data'; nothing about auth requirements, rate limits, error behavior on invalid postcodes, or how the lite response differs from the full version.

Agents need to know what a tool does to the 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 line, but a large part of it is a restatement of the name plus a URL path already implied by the tool name. There is no substance beyond the label.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 lookup with 4 params (2 untyped), 0% schema coverage, no annotations, and no output schema, the description supplies almost nothing an agent needs to invoke it correctly or interpret the result.

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

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

Schema description coverage is 0% and the description mentions no parameters at all. Two of the four properties (house_letter, house_number_addition) are untyped in the schema with no description compensation, and the postcode pattern is left entirely 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 verb-resource ('Lightweight property data lookup') and the Dutch domain term (pandgegevens). However, it doesn't distinguish from the sibling 'getapi_property_pandgegevens' – the word 'lightweight' hints at a difference but never articulates what fields or cost the lite variant omits.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, when-not-to-use, or alternative routing is given. The presence of a full 'pandgegevens' sibling makes the missing guidance especially costly – an agent cannot tell which to pick.

Agents often have multiple tools that could apply. Explicit usage 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 discloses almost nothing beyond the endpoint path. It does not mention authentication requirements, rate limits, error behavior for invalid/unknown plates, or what the 'extended response' actually 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 dense line with the resource front-loaded, followed by the variant tag and endpoint path. Nothing is wasted, though the bracketed path is mildly redundant with the tool name.

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

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

For a single-parameter lookup with no output schema, the description is minimal but borderline adequate. It omits what the extended response returns and how failures surface, leaving meaningful gaps for an agent that has to interpret the result.

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

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

Schema description coverage is 0%, but the schema itself constrains the value (pattern, 4-9 chars, alphanumerics with dashes/spaces). The description adds the crucial semantic that the string is a Dutch kenteken (license plate), which meaningfully clarifies the parameter, though it adds no format or normalization guidance.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Vehicle lookup by Dutch license plate (kenteken)') and flags the 'Pro / extended response' variant, which implicitly distinguishes it from the sibling getapi_rdw_vehicle-lite. The sibling contrast is suggested rather than named outright, 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 only a faint hint of when to use it ('Pro / extended response'), with no explicit condition such as 'use this when you need full vehicle data; use rdw_vehicle-lite for basic lookups'. An agent must infer the choice entirely from the adjective 'Pro'.

Agents often have multiple tools that could apply. Explicit usage 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 and discloses almost nothing: it implies a GET read, but says nothing about authentication, rate limits, error behavior for unknown plates, or which data the 'lite' projection omits versus the full variant.

Agents need to know what a tool does to the 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 no filler, and the endpoint tag is bracketed at the end where it does not interrupt the primary statement. Efficient, though it is terse to the point of under-specification.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, no annotations, and a nearly bare input schema, the description should explain what the lookup returns and how 'lite' differs from getapi_rdw_vehicle. It supplies neither, so an agent cannot predict the result shape or the trade-off.

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

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

Schema description coverage is 0%, so the description must compensate; it identifies the single parameter as a Dutch license plate (kenteken), which is genuinely useful vocabulary. However it gives no format, normalization, or casing guidance despite the schema enforcing a pattern and length bounds, leaving the constraint undisclosed in prose.

Input schemas describe structure but not intent. Descriptions should explain 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: a vehicle lookup keyed on a Dutch license plate (kenteken), with the HTTP endpoint appended. The gap is that it never differentiates itself from the sibling getapi_rdw_vehicle, so 'lite' is left for the agent to decode on its own.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the obvious alternative, getapi_rdw_vehicle. An agent choosing between the lite and full variants gets no criteria, only the implied adjective 'lightweight'.

Agents often have multiple tools that could apply. Explicit usage 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, yet it discloses nothing beyond the HTTP verb and path. For a scraping operation there is no mention of rate limits, authentication requirements, target-page fetchability, or what happens on unreachable/invalid URLs.

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

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

It is short, but this is under-specification rather than conciseness. The only content beyond the tool name is a method/path bracket that duplicates machine-readable metadata rather than helping selection.

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

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

A nested-object, single-required-parameter scraping tool with no annotations and no output schema needs substantial description, and it receives none. Nothing tells the agent what the call returns or how to 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 0% and the description adds no meaning for the single nested body.url parameter. The schema only says it is a bare string, so the agent gets no guidance on whether it expects a full page URL, domain, or something else.

Input schemas describe structure but not intent. Descriptions should explain 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 action ('E-mail Address Extractor') and exposes the underlying endpoint (POST /v1/scraping/email), which hints that scraping is involved. However, it never says what is extracted from where, and it does not distinguish this tool from the many sibling e-mail tools (validation_email, validation_email_batch, validation_email_disposable), so the agent cannot tell scraping from validation.

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

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

There is no statement of when to use this tool versus the sibling e-mail validators, no prerequisites, and no exclusions. The bracketed endpoint is not usage guidance.

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

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

No annotations provided, so the description carries the full burden. It reveals the POST endpoint but doesn't state whether this is read-only despite the mutating HTTP verb, what blacklists are queried, rate limits, 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 efficient sentence with the endpoint appended. Front-loaded with the action and resource, and nothing 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 single-parameter validation tool with no output schema, the description covers the essential purpose but leaves response format, blacklist coverage, and auth requirements undocumented. Adequate but with clear gaps given zero annotation coverage.

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

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

Schema coverage is 0% and there is one nested body parameter with an 'ip' field. The description implies an IP is supplied but adds no format details (IPv4 vs IPv6) beyond that, though the single-parameter context makes this a minor gap.

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

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

States a specific verb (Check) and resource (IP against DNS-based blacklists/RBLs), which is clearer than most siblings. However, it doesn't differentiate itself from getapi_lookup_ip or other validation tools beyond the DNSBL scope.

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

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

No explicit when-to-use guidance or alternatives are named. An agent must infer that this is for blacklist checking specifically, with no indication of when to prefer it over getapi_lookup_ip.

Agents often have multiple tools that could apply. Explicit usage 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, and it delivers almost nothing: no statement of what 'validate' means (syntax only, MX/deliverability, SMTP probe), whether the call costs credits or is rate-limited, or what the result indicates. The endpoint bracket is metadata, not behavioral context.

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

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

A single front-loaded sentence with zero filler, which is the right shape for this tool. It is terse rather than padded, though the endpoint bracket arguably belongs in metadata rather than 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?

With no annotations and no output schema, the description must explain the response shape and the tool's limitations, and it explains neither. An agent cannot tell what comes back (valid/invalid flag, reason codes) or how this differs from the disposable and batch siblings, leaving the definition inadequate for correct invocation.

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

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

Schema description coverage is 0% and the single parameter is a nested body object, so the description technically must compensate and does not. It does, however, name the resource ('email address'), which makes the lone string property self-evident; a baseline 3 reflects that the schema structure is clear enough for a one-field input.

Input schemas describe structure but not intent. Descriptions should explain 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 email address') and even pins the HTTP endpoint, so the core action is unambiguous. However, it makes no attempt to distinguish itself from close siblings like getapi_validation_email_batch or getapi_validation_email_disposable, which is exactly where an agent is most likely to pick the wrong 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 guidance on when to use this single-address validator versus the batch variant or the disposable-check variant that sit in the same sibling set. The agent is left to infer usage entirely from the 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses only the HTTP method and path; it says nothing about authentication needs, rate limits, maximum batch size, cost, or what a result contains. For a network-calling validation tool this leaves most behavior opaque.

Agents need to know what a tool does to the 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, front-loaded with the action and resource, with the endpoint appended as secondary detail. Nothing is wasted, though it is arguably too terse to be fully useful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, 0% parameter coverage, and a nested input object, the description should do far more. It omits batch limits, result format, and behavioral caveats, leaving an agent unable to call it correctly without guessing.

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

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

Schema description coverage is 0% and the single parameter is a nested object (body.emails). The description adds no information about the emails array, per-item constraints such as the 255-char limit, or the response shape, so it does not compensate for the undocumented schema.

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

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

States a specific verb and resource ('Validate a batch of email addresses') and the 'batch' qualifier distinguishes it from the sibling getapi_validation_email, which handles a single address. The endpoint in brackets adds concrete API context. It stops short of explicitly naming the sibling, but the purpose 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?

The word 'batch' implicitly signals when to prefer this over the single-address sibling, but there is no explicit when-to-use statement, no mention of batch-size limits, and no named alternatives. Usage must be inferred rather than read.

Agents often have multiple tools that could apply. Explicit usage 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 discloses almost nothing beyond the endpoint path. It does not state whether this is a read-only lookup, what it returns (boolean, score, domain list), or any auth/rate-limit behavior.

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

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

A single front-loaded line with no wasted words, but it is terse to the point of under-specification; the bracketed endpoint is the only additional detail.

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

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

No output schema, no annotations, and a nested request object wrapper left unexplained. An agent cannot tell what the response contains or how to interpret a 'disposable' result, which is core to calling this correctly.

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

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

The single nested body.email parameter has 0% schema description coverage, and the description supplies no format, example, or constraint guidance. 'Disposable email domain checker' only loosely implies the input is an email address.

Input schemas describe structure but not intent. Descriptions should explain 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 function: checking whether an email domain is disposable, plus the HTTP endpoint. The 'disposable' qualifier partially distinguishes it from siblings like getapi_validation_email and getapi_validation_email_batch, though it never names them.

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

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

There is no guidance on when to choose this over the closely-named general email validator or the batch variant. The purpose implies a use case, but the description offers no conditions, prerequisites, or alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses very little: nothing about what a successful validation returns, what the BIC field does when supplied (or omitted), error/failure semantics for invalid IBANs, or rate limits. Despite the POST endpoint implying a submission, no mutability or side-effect context is given.

Agents need to know what a tool does to the 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 pairing the operation with the resource, plus the route. Nothing is wasted, though the terseness comes at the cost of missing guidance rather than being deliberately economical.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 annotations, no output schema, and parameters that include an undescribed 'bic' field, the description leaves too much unspecified: there is no statement of what 'valid' means, what the response contains, or whether BIC is required alongside IBAN. It is not complete enough for an agent to call it confidently.

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

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

Schema description coverage is 0% and the parameters live inside a nested body object, where 'bic' has no type or description at all. The description does mention IBAN and BIC, which maps loosely to the two body fields, but adds no format, length, or optionality detail beyond what the schema already constrains.

Input schemas describe structure but not intent. Descriptions should explain 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 clear verb+resource ('Validate an international IBAN / BIC') and includes the endpoint path, so an agent can tell it apart from sibling validators like getapi_validation_vat or getapi_validation_email at a glance. It does not name a specific sibling, but the resource 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 or when-not-to-use guidance, no prerequisites, and no indication of how it relates to the other validation tools in the family (email, VAT, DNSBL). The usage is only implied by the word 'Validate'.

Agents often have multiple tools that could apply. Explicit usage 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 falls short: it does not say whether the call is read-only, whether it hits the live VIES service (with possible rate limits/timeouts), how an invalid VAT is reported (error vs. negative result), or what the response contains. Only the HTTP method and path are disclosed.

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

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

A single front-loaded sentence with the verb and resource first and the endpoint appended as reference metadata. No filler or redundancy.

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

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

For a validation endpoint with no annotations, no output schema, and no parameter descriptions, the definition is incomplete: the agent cannot know the result shape (valid flag, company name/address), failure semantics, or whether this is a live external lookup with latency or quota implications.

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

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

Schema coverage is 0%, but the schema itself carries a strict pattern (^[A-Z]{2}[A-Z0-9+*]{2,13}$) that documents format constraints. The description adds meaningful scope by specifying 'EU VAT number (VIES)', telling the agent the number must be an EU/VIES-eligible identifier with country prefix, but gives no example or country-code guidance beyond that.

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

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

States a specific verb (Validate), a specific resource (EU VAT number), and names the authority (VIES), plus the underlying endpoint POST /v1/validate/vat. An agent can tell it apart from the sibling validation tools (iban, email, dnsbl) by the VAT resource alone, 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling validation tools. Usage is only inferable from the verb 'Validate', which is the minimum implied context.

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