NeuralVerge

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context with the cost model ('Flat 5 points per successful run'), which matters for budgeting calls, but it says nothing about failure behavior (e.g., invalid ID) or response shape beyond the field list.

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 with the core capability front-loaded and the cost note appended. Every clause carries information; there is no filler.

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

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

With no output schema, the enumeration of returned fields (price tiers, MOQ, attributes, variants, supplier) does real work in telling the agent what to expect from a single-product detail call, and the annotations cover safety. Only error/edge-case behavior is unaddressed, which is a minor gap for a one-parameter read tool.

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

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

Schema description coverage is 100% and the single required parameter is fully documented there. The description's 'ID or URL' merely restates the schema's 'Product ID or URL' and adds no format or edge-case detail, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get full Alibaba product details') plus the input forms ('by ID or URL') and enumerates the returned data (price tiers, MOQ, attributes, variants, supplier). The singular, identifier-based scope implicitly separates it from run_alibaba_product_search, but the sibling is never named, so it stops short of explicit differentiation.

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 statement and no named alternative. Usage is only implied: the 'by ID or URL' phrasing signals this is a lookup that follows a search, which is a reasonable but weak cue.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds a genuinely useful behavioral trait absent from annotations: the cost model ('1 point per returned record'), which tells the agent to be economical with count. It omits pagination/rate-limit behavior, so a 3 is warranted.

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, purpose front-loaded followed by the cost model. Every phrase carries information; only minor room to tighten.

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 with full schema coverage and rich annotations, the description is adequate: it covers the action, returned fields, and cost. It stops short of routing guidance to the detail sibling, leaving 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 documents both keyword and count (including the 250 cap and default 25). The description only restates 'by keyword' and adds nothing about the count parameter or keyword format, matching the baseline-3 expectation when the schema does the heavy lifting.

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

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

States a clear verb+resource ('Search Alibaba products by keyword') and enumerates the returned data (price, MOQ, supplier, certifications), which distinguishes it from the detail-oriented sibling run_alibaba_product. It does not, however, explicitly name siblings to differentiate from the many other marketplace search 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?

There is no when-to-use guidance, no prerequisite note, and no reference to the alternative run_alibaba_product for full detail lookup. The agent must infer that this is the entry point for Alibaba discovery purely 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false. The description adds genuinely new behavioral context not derivable from annotations: a cost model ('Flat 5 points per successful run'). It stops short of auth or rate-limit details, but for a simple read this is solid added value.

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 action and followed by the cost detail. No filler, and 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 single-item read-only lookup with 100% schema coverage, the description is nearly sufficient; listing the returned fields compensates for the absent output schema. Only the missing when-to-use guidance keeps it from a 5.

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

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

Schema description coverage is 100% and the schema already documents the product ID/URL and both enum parameters. The description adds only 'by ID', which restates the schema's own example; baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb (Get) and resource (AliExpress product details by ID) and enumerates the returned fields (title, price, images, store). This implicitly separates it from run_aliexpress_product_search and run_aliexpress_product_reviews, though it never names those siblings 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?

The description gives no indication of when to use this tool versus the sibling search or reviews tools, nor any prerequisites. The 'by ID' phrasing hints at single-item lookup but no explicit routing guidance is 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?

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds genuine value beyond that: it discloses the credit cost ('1 point per returned record') and the shape of the payload returned, which the annotations do not.

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 sentences with zero filler: the primary action and payload come first, and the billing note follows immediately. Nothing 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?

With no output schema, the description usefully names the returned fields and the per-record cost. It is sufficient for an agent to call the tool correctly, though it says nothing about pagination behavior or how many records a single call can yield beyond the schema's max_items cap.

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%, including enum explanations for filter, currency, and language, so the schema carries the parameter burden. The description only reinforces that the product argument is an ID; it adds no semantics for max_items, translate, or the enum options. 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 (get buyer reviews for an AliExpress product), and enumerates the returned data (rating, text, buyer details). It is clearly distinguishable in kind from run_aliexpress_product and run_aliexpress_product_search, though it never names those siblings explicitly, which keeps it from a 5.

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

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

The phrase 'by ID' implies the prerequisite that a product identifier is needed, and the tool's name implies the review-fetching use case. However, there is no statement of when to prefer this over run_aliexpress_product or the search tools, and no exclusions or preconditions about which IDs are valid.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds genuinely new behavioral context: a billing/cost trait ('1 point per returned record') and the shape of results (title, price, image) that the annotations do not convey.

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

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

Two short sentences with the verb and resource front-loaded and the cost note appended. Nothing is padded and every clause carries information.

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

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

For a 15-parameter search with no output schema, the description covers purpose, return fields, and cost, while annotations cover safety. It is largely complete, with only minor gaps around pagination/result volume beyond what max_items and start_page already imply.

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 15 parameters are already documented in the schema, and the description adds no parameter-level detail. The baseline of 3 is appropriate when the schema carries the full parameter burden.

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) and resource (AliExpress products) and even lists the returned fields (title, price, image). It is clear, but it does not explicitly distinguish itself from sibling tools like run_aliexpress_product (single-item detail) or run_aliexpress_product_reviews.

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 alternative tools are named. The keyword-search intent is only implied by the tool name and the word 'keyword', leaving the agent to infer routing against the large marketplace search sibling set.

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

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

Annotations already carry readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds genuinely non-redundant context: the exact cost model ('flat 5 points per successful run') and the set of fields returned. It stops short of describing failure behavior for invalid ASINs or missing domains.

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

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

Two sentences, no filler. The payload and key are front-loaded, and the cost sentence is a single tight clause that earns its place as a decision input.

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

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

For a read-only, two-parameter lookup with no output schema, the description compensates well by enumerating returned fields and the cost. What remains thin is the domain default behavior (only in the schema) and there being no mention of failed lookups, which is minor here.

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%: both 'asin' (with an example) and the 19-value 'domain' enum including the amazon.com default are fully documented in the schema. The description adds no syntax, format, or default detail beyond that, 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 and resource ('Get full Amazon product details') and pins the retrieval key ('by ASIN'), plus enumerates the payload fields (title, brand, price, images, rating, features, seller). This separates it from run_amazon_product_search, but it never names or contrasts with run_amazon_product_offers, which also operates per-ASIN.

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 ASIN-keyed lookup tells an agent to call this when it already has an ASIN, and the 'Flat 5 points per successful run' cost note is a useful routing cue against pricier search alternatives. There is no explicit when-not guidance, no prerequisites, and no named alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds a useful non-annotation detail: the flat cost of 5 points per successful run. It says nothing about result volume, pagination, or how many offers are returned, which is a real gap for an offer-listing 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 sentences: the first front-loads the resource, scope, and returned fields; the second states the cost. Nothing is wasted and the most important 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 read-only, two-parameter lookup with no output schema and full annotation coverage, the description covers purpose, returned fields, and cost. The one missing element is any indication of result volume or pagination behavior, which an agent calling across 19 domains might 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 parameters (asin, domain) are already documented with examples and the full domain enum. The description confirms the ASIN key but adds no syntax or default semantics beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (all marketplace offers for an Amazon product by ASIN) and enumerates the fields returned (price, condition, seller, delivery). This clearly distinguishes it from run_amazon_product (product detail) and run_amazon_product_search, though neither sibling is named explicitly.

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

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

Usage is implied by the 'offers' framing, but there is no explicit when-to-use guidance or routing versus run_amazon_product, run_amazon_product_search, or run_amazon_seller. The agent must infer that this is the tool for offer/listing data rather than catalog or seller data.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description still earns credit for adding two decision-relevant facts the annotations do not carry: pagination behavior ('across paginated results') and billing cost ('1 point per returned record'), which directly affects how an agent sizes max_items.

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

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

Two sentences, no filler, and the core action plus output shape is front-loaded before the cost note. 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?

With no output schema, the description usefully names the returned fields and discloses pagination and per-record cost. What is missing is any hint of how start_page/max_items interact with paging or where results are truncated, but for a four-parameter search tool this is close to sufficient.

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%, including a fully enumerated domain list and defaults for max_items, start_page, and domain, so the schema does the heavy lifting. The description adds nothing beyond implying pagination and cost-per-record; 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/extract) and resource (Amazon product listings) and even enumerates the returned fields (title, URL, price, rating). It is clear on its own, but it never names the obvious alternative run_amazon_product (single-product lookup) or run_amazon_seller_products, so the agent must infer the distinction from names 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?

There is no when-to-use guidance, no prerequisites, and no routing to alternatives despite four Amazon siblings and dozens of other marketplace search tools. The agent can infer that a search tool is for discovery, but nothing in the text helps it choose between this and run_amazon_product_search equivalents on other domains.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the useful but limited cost detail 'Flat 5 points per successful run' and does not add auth, rate-limit, or error 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?

Two front-loaded sentences: the purpose comes first, followed by cost. Every sentence is short and useful for an agent evaluating whether to invoke the tool.

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

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

No output schema exists, so the description appropriately lists returned profile contents (name, rating, business details, contact info). Combined with the fully documented input schema and annotations, this is nearly complete, though it omits potential response behavior such as missing-seller handling.

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 seller ID and domain enum are fully documented in the schema. The description only restates 'by seller ID' and adds no new parameter syntax or default behavior beyond the schema.

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

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

States a specific verb and resource ('Get an Amazon seller profile by seller ID') and names the returned fields. It is clear but does not explicitly distinguish itself from sibling tools such as run_amazon_seller_products or run_amazon_product.

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 no when-to-use guidance, no exclusions, and never mentions alternatives. It only states what the tool does, leaving the agent to infer when it is appropriate versus product-related sibling tools.

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

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

The annotations already cover the safety profile (readOnlyHint: true). However, the description adds significant behavioral context by listing the exact data fields returned (title, URL, price, rating, and image), which is valuable information absent in the formal schema.

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

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

The description is extremely concise. It states the primary function and then efficiently lists all the returned data points in a single, impactful 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?

Given the simplicity of the operation (listing products) and the completeness of the input schema, the description is highly complete. It clearly communicates the required function and the scope of the 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 description coverage is 100%, so all parameters are thoroughly defined in the structured schema. The description adds no unique meaning or clarification regarding the structure or purpose of the input 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 uses the specific verb 'List products' and scopes it precisely to 'an Amazon seller's storefront.' This clearly differentiates it from general product search or listing tools like run_amazon_product_search.

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

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

The tool scope is clear (seller products), but the description does not explicitly guide the agent on when to use this function versus related Amazon seller functions. Usage is implied by the focus on the seller storefront.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive, open-world lookup. The description adds useful behavioral context by naming the returned fields and disclosing the cost ('5 points per returned record'), though it does not describe error handling or authentication requirements.

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

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

The definition is front-loaded with the core lookup purpose and follows with returned fields and cost. Every sentence contributes useful information without repetition or filler.

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

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

For a simple one-record lookup with one required parameter and no output schema, the description provides the source registry, accepted identifier, returned fields, and cost. Nothing essential for correct invocation appears to be missing.

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

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

Schema description coverage is 100%, and the schema already documents the sole parameter as a CUIT or registry URL with an example. The description restates that accepted identifier but does not add format rules or validation details beyond the schema, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get one company from the Argentina registry of legal entities' and names the registry (IGJ). The single-company scope and accepted identifiers (CUIT or registry link) clearly separate it from the list-oriented run_ar_companies_search sibling.

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

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

It gives a clear usage context by specifying that the tool retrieves one company by CUIT or registry link. It does not explicitly name run_ar_companies_search as the alternative for broader searches, so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description usefully adds the pricing model ('1 point per returned record'), which is real behavioral context not present in structured fields, though it omits pagination/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 dense, front-loaded sentence that leads with the action and resource, then the lookup keys, then the returned fields, then the cost. Every clause carries information; the field enumeration makes it slightly long 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?

There is no output schema, so the description appropriately enumerates the returned fields. Combined with annotations covering safety and the description covering cost and search keys, the agent has what it needs, though pagination behavior ties to start_page/max_items and is left to 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?

With 100% schema coverage the baseline is 3, but the description adds value beyond the schema: the schema restricts keyword to 'Company name. e.g. ypf', while the description clarifies that search works by company name OR CUIT. It also frames the returned fields, complementing the param docs.

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 resource (Argentina registry of legal entities, naming RNS/IGJ) and enumerates the returned fields. It is clearly a search endpoint distinguishable from the sibling run_ar_companies detail tool by name and by the keyword-based search framing, though it never explicitly names that 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?

Usage is implied by 'search by company name or CUIT', which tells the agent what input to supply. However, there is no explicit when-to-use/when-not guidance and no mention of the sibling run_ar_companies (detail lookup) as an alternative, leaving the agent to infer the choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: the flat 5-point cost per successful run and the exact set of returned fields (name, status, legal form, address, previous names, paid extracts).

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

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

Two sentences, zero waste. The core capability and identifier formats are front-loaded, and the cost note is a single compact clause that 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?

With no output schema, the description usefully enumerates what is returned, which is exactly what an agent needs to judge relevance. It could go slightly further on failure behavior for an invalid or unknown FN, but it is complete for normal 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?

Only one parameter with 100% schema description coverage, so the schema already documents the 'company' field and even supplies the '56247t' example. The description restates the same accepted formats without adding syntax or validation detail beyond the schema; baseline 3 applies.

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

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

States a specific verb and resource ('Get one company from the Austria registry (Firmenbuch)') and names the accepted identifier forms (FN or registry URL). The singular 'one company' implicitly separates it from run_at_companies_search, but the sibling is never 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 required identifier input (FN or registry URL), which signals a direct lookup rather than a query. No explicit when-to-use guidance or named alternative (run_at_companies_search) is provided for an agent that only has a company name.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description's one addition is the cost disclosure ('1 point per returned record'), which is genuinely useful context not in the annotations, but returns/pagination behavior is left 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 tight clauses with no filler; the core purpose is front-loaded before the field list and the cost note. Efficient, though the trailing return-field enumeration makes the sentence a little 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?

With no output schema, the description appropriately names the returned fields (name, registration number, status, seat, link) and discloses the per-record cost. For a simple, fully-schema-covered search endpoint this is close to complete, missing only guidance on the run_at_companies sibling.

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

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

Schema coverage is 100% (baseline 3), but the description adds real value beyond the schema: it clarifies the keyword accepts either a company name or an FN (registration number), whereas the schema only describes keyword as 'Company 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 specific verb (Search), a specific resource (Austria company registry / Firmenbuch), and the accepted lookup keys (company name or FN), plus the returned fields. It's clear what the tool does, though it never explicitly distinguishes itself from the sibling run_at_companies.

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

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

The description implies when to use it by naming the searchable keys ('by company name or FN'), but gives no explicit when-not conditions and never routes the agent to the sibling run_at_companies (the non-search variant) or clarifies which to pick for a keyword lookup.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds the useful non-obvious operational fact that each successful run costs a flat 10 points, plus which fields come back. No rate-limit or failure behavior, so not a 5.

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

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

Two sentences, no filler. The lookup key and registry scope are front-loaded and the cost note is a compact trailing clause that 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 single-parameter read tool with no output schema, the description names the registry, the key, the returned fields and the cost — everything an agent needs before calling it. Nothing material is missing.

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

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

Schema coverage is 100% and there is a single parameter whose schema description already gives the format and an example. The description restates the accepted key types (registration number or registry URL) but adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (get), resource (one company), source (Australia registry, ASIC/ABN), lookup key (registration number or registry URL), and enumerates returned fields. It clearly contrasts with the sibling run_au_companies_search, which handles the multi-result case.

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 singular 'one company ... by registration number or registry URL' implies a single-record lookup, and the existence of run_au_companies_search implies this is the needle-not-haystack path, but neither the alternative nor the when-not condition is stated explicitly. Usage is inferable rather than spelled out.

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

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

Annotations already declare read-only, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds billing context ('1 point per returned record') and the data source (ASIC/ABN), which annotations do not convey and which an agent needs before incurring 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?

A single front-loaded sentence leads with verb and resource, then the cost note. It is tight, though the trailing field list (name, registration number, status...) reads ambiguously as either return fields or inputs.

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

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

With no output schema, the description usefully enumerates returned fields and discloses per-record cost. It does not explain pagination behavior despite start_page/max_items existing, but is otherwise complete 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 the schema fully documents keyword, status, max_items and start_page; baseline 3 applies. The description adds only the fact that keyword is a company name, which the schema already 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?

States a specific verb (Search) and resource (Australia company registry, ASIC/ABN), and scopes it to searching by company name. This distinguishes it functionally from the run_au_companies lookup sibling, though it never names that 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?

The verb 'Search' plus 'by company name' implies a keyword-lookup use case, but there is no explicit when-to-use guidance and no exclusion or routing against the many sibling country/company tools. Usage must be inferred.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds genuine value beyond that: the exact shape of the returned tree and the 'Flat 5 points per successful run' cost signal, though it says nothing about tree size, caching, or locale/region dependence.

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 with no padding. The resource and its field contents come first, with cost information trailing, so 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?

With no output schema, the description carries the burden of explaining the return shape and does so thoroughly (id, name, alias, parent id, level, URL). Minor gaps remain around whether the tree is region/language scoped and how large it typically is.

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?

Zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. The field list it does provide describes output, not inputs, which is appropriate here.

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 ('Get the Avito category tree: departments and sub-categories') and enumerates the returned fields, which cleanly separates it from the Avito item/seller siblings. An agent knows immediately this is a taxonomy lookup, not a listing search.

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

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

There is no explicit statement of when to call this versus run_avito_items_search or when not to call it. The intended use (fetch category ids before filtering item searches) is only implied by the returned fields, leaving the agent to infer the sequencing.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely useful context beyond them: the cost model ('Flat 5 points per successful run') and a breakdown of the returned payload, which matters since there is no output schema. It does not mention auth or rate limits, keeping it short of a 5.

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

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

The purpose and input scope are front-loaded in the first clause, and the cost sentence is a clean, useful addition. The middle enumeration of returned fields is long but earns its place given the absence of an output schema.

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

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

For a single-parameter read tool with no output schema, the description supplies both input guidance and an inventory of returned fields plus the cost, which is close to everything an agent needs. It stops short of describing pagination or error behavior, but those are minor here.

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 'item' parameter is already documented with an example ID in the schema. The description's 'id or URL' adds only marginal restatement of that fact, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get a full Avito listing') and constrains the input scope to 'by id or URL', which implicitly separates it from the run_avito_items_search sibling. It never names that sibling explicitly, 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?

The 'by id or URL' phrasing implies you use this when you already have an identifier rather than search terms, but there is no explicit when-to-use statement or named alternative. An agent must infer that run_avito_items_search is the counterpart for keyword discovery.

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

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

Annotations already establish read-only, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds genuinely new behavioral context the annotations do not: the returned field set (title, price, location, coordinates, image, seller) and the billing rule '1 point per returned record', which directly affects how an agent sizes max_items.

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

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

Three tight sentences: capability, return shape, cost. Front-loaded with the search action and free of filler. The middle clause is a long filter list, but every listed dimension maps to an actual parameter, so nothing is padding.

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

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

With 11 parameters, no output schema, and no nested objects, the description does the work of summarizing the return fields and the per-record cost, and the schema documents pagination (start_page, max_items) and value ranges. The main gap is the missing sibling routing to run_avito_items, which is minor for an otherwise self-contained 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%, including enum options for sort and seller_type and example values for region/category, so the schema carries essentially all parameter meaning. The description only restates the filter categories in prose, adding no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.

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

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

Clear verb+resource ('Search Avito listings by keyword') plus an enumeration of supported filter dimensions, so an agent immediately knows this is the keyword-search entry point. It does not, however, distinguish itself from the sibling run_avito_items (item lookup by ID), leaving the boundary between the two 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?

Usage is only implied: the presence of a required 'keyword' plus filters signals 'use this when you want to search rather than look up a known item', but the description never states when to prefer run_avito_items, run_avito_categories, or a competing marketplace search tool. No prerequisites, no exclusions.

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

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

The annotations already establish that this is a read-only, idempotent, open-world, non-destructive operation. The description adds useful behavioral detail beyond annotations by stating the flat 5-point cost per successful run and listing the fields returned, though it does not mention rate limits or error behavior.

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

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

The description is compact and front-loaded: it states the operation, input format, and returned fields without filler. The cost sentence is short and relevant.

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

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

With no output schema, the description compensates by listing the seller fields returned. Annotations cover the safety profile, the sole parameter is fully documented, and the cost is disclosed, leaving no major gap for an agent invoking this tool.

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

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

Schema coverage is 100%, and the single 'seller' parameter is fully documented in the schema with an example. The description restates that the input can be a slug or URL but adds no additional syntax or formatting guidance 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 verb and resource: 'Get an Avito seller (brand page)'. It also identifies the input form ('by slug or URL') and enumerates the returned seller fields, making it clearly distinct from sibling item/search tools.

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

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

It implies usage by explaining that the tool retrieves a seller by slug or URL, but it does not explicitly state when to choose this over related tools such as run_avito_items or run_avito_items_search. The intended context is clear enough, but alternatives are left to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds two things beyond them: the concrete payload contents (directors, establishment units, contact details) and the cost model '10 points per returned record', which is real behavioral information an agent needs before calling.

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: the resource and identifier forms come first, the payload contents and cost follow. No filler, no restating of the tool name, nothing that could be cut 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?

With no output schema, the field enumeration (name, status, start date, address, legal form, activities, directors, contact, establishment units) does the job of telling the agent what comes back, and pricing is disclosed. Minor gap: no indication of behavior on not-found or invalid enterprise numbers, or of response latency for the open-world lookup.

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

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

Schema coverage is 100% for the single parameter, and the schema already documents the accepted forms with an example ('0202.239.951'). The description restates the same two input forms without adding format rules, validation behavior, or what happens on an unmatched number, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get one company from the Belgium registry (KBO/BCE)') and enumerates the returned fields, so the scope is unambiguous. It signals single-record lookup versus the numerous 'run_*_companies_search' siblings, but never names run_be_companies_search as the alternative, so the differentiation is implied rather than explicit.

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

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

The phrase 'by enterprise number or registry URL' implies this is a direct-lookup tool for when you already have an identifier, which is useful usage context. However, there is no explicit when-to-use/when-not guidance and no mention of run_be_companies_search for the case where only a name is known.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety profile is covered. The description adds genuinely useful context beyond annotations: the returned fields and the cost model ('1 point per returned record').

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 with the operation and dataset front-loaded and no wasted text; the cost note is appended efficiently.

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

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

No output schema, but the description enumerates the returned fields (name, enterprise number, status, address, link), which compensates well. Lacks pagination/return-format detail, but overall sufficient for a 4-param search.

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 (keyword, status, max_items, start_page) are documented in the schema. The description only echoes the name-based search, adding no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Search) and resource (Belgium company registry KBO/BCE) and scopes it to lookup by company name. This distinguishes it from the plain run_be_companies sibling, though that sibling is not 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?

Implies use when you want to find Belgian companies by name, but gives no explicit when-to-use vs run_be_companies (single record lookup), nor any exclusions or prerequisites. Usage is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuine context beyond that: the credit cost ('Flat 5 points per successful run') and the shape of the payload returned, which no annotation conveys.

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 for purpose and return contents, one short sentence for cost. Front-loaded with the verb and lookup key, zero filler.

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

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

No output schema exists, but the description enumerates the returned fields (name, tagline, makers, topics, screenshots, similar startups), which largely compensates. Minor gap: no note on error behavior when a slug is unknown or on how the URL form is parsed.

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

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

Schema coverage is 100% and the single parameter is already documented with an example ('e.g. iconscove'). The description restates 'slug or URL' but adds no format nuance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get one startup from BetaList') plus the lookup key ('by slug or URL'), and enumerates the returned fields. The phrase 'one startup' cleanly separates it from run_betalist_startups_search and run_betalist_startups_latest without needing to name 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 rather than stated: an agent can infer this is the tool to use when it already holds a slug or URL. There is no explicit when-to-use/when-not guidance and no named alternatives, even though three sibling BetaList tools exist that could confuse selection.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), and the description adds genuinely new context: the returned record fields and the cost model ('1 point per returned record'). It does not describe pagination behavior, but the annotation coverage lowers the bar.

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 resource and ordering, then names the return fields and cost. No wasted words.

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

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

With no output schema, the description helpfully enumerates the returned fields (name, tagline, logo, link) and flags the credit cost. Adequate for a simple list tool, though pagination/limit behavior is left entirely to 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 description coverage is 100%, so both parameters (max_items, start_page) are already documented in the schema. The description adds no parameter meaning beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific resource (newest BetaList startups), an explicit ordering ('newest first'), and the returned fields. An agent can tell it lists recent launches, distinct from the sibling run_betalist_startups_search, 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?

The 'newest first' framing implies the use case (browse recent launches) but there is no explicit when-to-use, no exclusions, and no routing against the closely related run_betalist_startups or run_betalist_startups_search 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?

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds genuinely new context beyond that: the credit cost ('1 point per returned record') and the shape of the returned fields (name, tagline, logo, link), which is real value not present in the annotations.

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

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

Two compact clauses with no wasted words; the search scope is front-loaded and the cost note is appended efficiently. Slightly terse phrasing ('by keyword: name, tagline, logo and link') leaves the relationship between keyword and returned fields implicit, but 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?

With no output schema, the description helpfully enumerates the returned fields and discloses the per-record cost. It does not mention pagination behavior despite the start_page parameter, which is a minor gap for a paginated search tool, but overall it covers what an agent 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 description coverage is 100%, with keyword, max_items (up to 250, default 25), and start_page all documented in the schema. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (search) and resource (BetaList startups), scoped by keyword, and names the fields returned (name, tagline, logo, link). The 'by keyword' phrasing loosely separates it from the non-search siblings, but it never names run_betalist_startups, run_betalist_startups_latest, or run_betalist_topics_startups 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 description implies a keyword-search use case but gives no when-to-use guidance and no exclusions relative to its close siblings (the plain list, latest, and topics variants). An agent must infer from the tool name alone which of the four BetaList tools 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?

Annotations already declare readOnly/idempotent/non-destructive/open-world, so the safety profile is covered. The description adds genuinely new behavioral context: the shape of each record (name, tagline, logo, link) in the absence of an output schema, plus the per-record point cost, which is operationally relevant for budgeting calls.

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

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

A single dense sentence that front-loads the resource and scope, then lists return fields and cost. Nothing is wasted, though the parenthetical list of accepted topic forms makes it slightly harder to parse at a glance.

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

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

With no output schema, the description usefully names the returned fields and the cost model, and the input schema covers pagination. Missing only sibling differentiation and any note on how max_items/start_page interact with the point cost.

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

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

Schema description coverage is 100%, so topic, max_items and start_page are all documented in the schema itself. The description only echoes the topic slug format ('generative-ai', URL) without adding syntax or behavior 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+resource: startups belonging to a single BetaList topic, with the accepted topic forms and the returned fields. It is clear what the tool fetches, but it never distinguishes itself from the sibling run_betalist_startups (all startups) or run_betalist_startups_search, leaving the boundary to be inferred.

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. An agent cannot tell from the text whether this topic-scoped fetch should be preferred over run_betalist_startups or run_betalist_startups_search, so selection must be guessed 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?

Annotations already cover readOnly, idempotent, openWorld and non-destructive, so the safety profile is handled. The description adds genuinely non-schema information: the credit cost ('15 points per returned record') and the full breadth of returned data, which is exactly what an agent needs for cost-aware planning. It omits failure behavior (invalid UIC, non-registry 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?

Front-loaded with the verb, source and identifier types before the long field enumeration, and the pricing note is isolated at the end. The middle field list is dense but every item is a real returned section, so it earns its space.

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

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

For a read-only single-record lookup with no output schema, the description enumerates the returned sections (registration data, officers, procuracy, mergers, beneficial owners, court files) well enough for an agent to judge suitability, and states the cost. Only error/not-found behavior and the search alternative are missing.

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

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

Schema coverage is 100% and the single parameter already documents 'UIC (ЕИК) or registry URL' with an example. The description restates the same two accepted formats without adding format rules, validation behavior, or what happens when a URL is not a Bulgarian registry link. 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: 'Get one company from the Bulgaria registry (Commercial Register)', and 'one' distinguishes it from a listing/search operation. It never names run_bg_companies_search or run_bg_company_filings, so the differentiation is implied rather than explicit.

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

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

'Get one company ... by UIC (ЕИК) or registry link' implies this is the single-record lookup versus the search sibling, but no when-to-use / when-not guidance is stated and no alternative is named. The accepted input formats are the only actionable guidance.

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

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

Annotations already cover readOnly, idempotent, openWorld and non-destructive semantics, so the bar is lower. The description adds genuine behavioral context beyond them: the per-record point cost, which matters for batching decisions, and the shape of returned records. It stops short of disclosing pagination interplay between max_items/start_page.

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 covers scope, search keys and return fields, with the cost note appended. Every element earns its place with no filler, though the return-field list could be trimmed since the fields aren't callable inputs.

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 search with full schema coverage and no output schema, the description supplies the missing pieces an agent needs: what registry it hits, the searchable keys, the returned field set, and the cost. Little is left ambiguous, only pagination behavior is 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 schema already documents keyword, max_items and start_page, giving a baseline of 3. The description adds marginal value by noting UIC is a valid search key even though the schema labels keyword only as 'Company name', but it adds nothing for the pagination parameters.

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

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

States a specific verb (Search) and resource (Bulgaria company registry / Commercial Register), plus what it can be searched by (name or UIC) and the returned fields (name, UIC, legal form, card link). This clearly distinguishes it from run_bg_companies, the single-company sibling, though it never names that alternative explicitly.

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

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

It conveys how to search (by company name or UIC) and includes cost awareness ('1 point per returned record'), which implies usage. But there is no explicit when-to-use vs when-not, no mention of when to prefer run_bg_companies for a single lookup, so 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?

Annotations already declare this a safe, idempotent, open-world read. The description adds genuinely new context beyond them: the newest-first ordering, the exact fields returned, and the billing model ('1 point per returned record'). That pricing/sort disclosure is real value.

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 verb and resource before the field list and cost note. Every clause carries information; it is slightly packed but not wasteful.

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

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

With no output schema, the description carries the burden of explaining returns and does so (announcement date, act type, title, document link, with example document types). Pagination behavior is not covered, but the safety profile is handled by annotations.

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. The description reinforces the accepted forms of the required company parameter (UIC or registry URL) but adds nothing on max_items or start_page, so baseline 3 is appropriate.

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

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

States a specific verb (List) and a precise resource (announced acts of a Bulgaria company in the Commercial Register), and enumerates the returned fields. This clearly distinguishes it from run_bg_companies and run_bg_companies_search, which surface company data rather than filings.

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

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

It tells the agent what input is needed (UIC/ЕИК or registry URL) and that results come newest-first, which implies the use case. But it never says when to prefer this over run_bg_companies_search or how to obtain a UIC in the first place, so usage 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the cost model ('Flat 5 points per successful run') and enumerates returned fields, but says nothing about auth needs, not-found behavior, or rate limits beyond that.

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 sentences, front-loaded with the core lookup description. The pricing sentence is slightly tangential to tool selection but is short and adds cost awareness, so little is wasted.

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

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

With no output schema, the description usefully enumerates return fields, and the parameter is fully specified in the schema. It is nearly complete for a read-only single-record lookup, with only edge-case behavior (missing company, identity/auth) left unstated.

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

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

Schema description coverage is 100%, so the single 'company' parameter is already documented with an example. The description restates 'registration number or registry URL' with no extra format detail, so baseline 3 applies since the schema carries the load.

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 ('Get one company from the Brazil registry') plus the source system (CNPJ / Receita Federal) and the fields returned (name, status, registration date, address, legal form). The singular 'one company' contrasts with the run_br_companies_search sibling, so an agent can distinguish single-entity lookup from search.

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

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

Usage is only implied: the tool fetches a single company by identifier. There is no explicit 'when to use this vs run_br_companies_search' guidance, no prerequisites, and no exclusions, leaving the agent to infer that search should be used for discovery.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint, openWorldHint). The description adds genuinely useful context beyond that: the underlying data source (CNPJ / Receita Federal) and, notably, a pricing/cost disclosure ("1 point per returned record") that no annotation conveys. It does not describe pagination or result ordering, so it is not exhaustive.

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

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

The definition is front-loaded with the core action and data source, then a short fragment covering output fields and pricing. It is compact and wastes little space, though the field list "name, CNPJ, status and link" is slightly ambiguous about whether it describes outputs or inputs.

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

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

With no output schema, the description partially compensates by naming returned fields, and it discloses the cost model. For a simple read-only search over four well-documented parameters, this is nearly complete; only pagination behavior and result-ordering are unaddressed, and those live 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 description coverage is 100%, so the schema already documents all four parameters including the status enum and max_items bounds. The description adds no parameter-specific syntax or format detail beyond what the schema provides; "name, CNPJ, status and link" reads as returned fields rather than input parameters. Baseline 3 is appropriate.

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

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

The description states a specific verb (Search) and resource (Brazil company registry / CNPJ / Receita Federal data) and specifies the search key (company name). It also lists the returned fields, making the tool's scope clear. It does not explicitly name the sibling run_br_companies (the non-search variant), so it stops short of full sibling differentiation.

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?

"Search ... by company name" implies the usage condition (name-based lookup) but gives no explicit when-to-use vs when-not guidance and does not contrast with run_br_companies, which is presumably the retrieve-by-identifier sibling. Usage is inferable but not spelled out.

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

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

Annotations already cover read-only, idempotent and open-world nature, and the description adds the crucial cost signal ("5 points per returned record") plus the scope of data returned. It does not mention what happens when the corporation number is invalid or whether all fields are always populated.

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 that leads with the action and source before the field enumeration. The long list of returned fields is somewhat dense but each item earns its place given there is no output schema.

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

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

With no output schema, enumerating the returned fields (name, status, incorporation date, address, legislation, directors, control persons, filings, name history) is the key contribution and it is present, along with pricing. Minor gap: no indication of error behavior for unresolvable identifiers.

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 `company` parameter is documented with an example (426160-7). The description restates the accepted forms (number or registry link) but adds no format or validation detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ("Get one federal corporation from the Corporations Canada registry") plus the two accepted identifiers, and enumerates the returned fields. It is clearly distinct from the sibling search tool run_ca_companies_search and from run_ca_company_filings.

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 "one corporation ... by corporation number or registry link" phrasing makes clear this is a single-record lookup, implicitly requiring the identifier first, but it never names run_ca_companies_search as the way to obtain that number, nor any failure conditions.

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

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

Annotations already declare the full safety profile (readOnly, idempotent, openWorld, non-destructive), so the burden is lighter. The description adds genuinely non-structured context: the 'federal corporations only' scope and the '1 point per returned record' cost signal, which matters for an agent deciding how broadly to query. It still omits pagination behavior across start_page/max_items.

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?

Effectively one front-loaded sentence covering purpose, searchable keys and returned fields, plus a short cost note. It is tight and well-ordered, with only the trailing field list reading slightly like a run-on.

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

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

With no output schema, the description usefully enumerates the returned fields (name, corporation number, status, business number, link) and adds scope and cost. Pagination semantics and the 250-item ceiling live only in the schema, but for a search tool this covers what an agent needs 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 coverage is 100%, so the schema documents keyword, status, max_items and start_page on its own. The description adds that the keyword accepts a corporation number or business number as well as a name, extending the schema's narrow 'Corporation name' wording, but this is marginal and the status/paging params are untouched.

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

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

The description states a specific verb+resource ('Search federal corporations in the Corporations Canada registry') and scopes it to name/number/business-number queries. It distinguishes this Canadian registry source from the many other country registries in the sibling list, though it never names run_ca_companies (the detail lookup) explicitly.

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

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

It implies usage by listing the searchable keys (name, corporation number, business number), but gives no explicit when-to-use/when-not guidance and no routing to alternatives like run_ca_companies or run_ca_company_filings. The agent must infer the search-vs-detail boundary from the name 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful trait beyond annotations — '1 point per returned record' — but says nothing about pagination behavior across max_items/start_page, so it is only partially additive.

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 sentences with no wasted words; the scope constraint (one federal corporation, registry) is front-loaded. The cost clause is short and earns its place, though it reads as appended rather than integrated.

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

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

With no output schema, the description usefully previews the returned fields (date, type, amendment details) and pagination is handled by the schema's max_items/start_page. Annotations carry the safety profile, so an agent has enough to call it correctly; only explicit sibling routing 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 company, max_items and start_page are already fully documented in the schema. The description contributes no additional parameter syntax or format detail beyond the 'one corporation' scope constraint, matching the baseline 3 for schema-heavy definitions.

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

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

States a specific verb+resource: 'Certificates and filings of one federal corporation in the Corporations Canada registry,' plus the fields returned (date, type, amendment details). This distinguishes it from the company-listing sibling run_ca_companies, but it never names the alternative 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 guidance, no prerequisites, and no reference to alternatives such as run_ca_companies or run_ca_companies_search. The agent must infer that it needs a known corporation number and that this is a filings-specific pull.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description usefully adds a cost dimension ('Flat 5 points per successful run') that annotations do not convey, but says nothing about pagination or result size for an openWorld listing.

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 purpose and returned fields come first, the pricing note second. Zero filler 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 no-parameter listing tool with full annotation coverage and no output schema, the description covers purpose, fields, and cost. It could note pagination or whether the listing is exhaustive, but nothing essential is missing.

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

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

The tool takes zero parameters, so the baseline is 4. There are no parameter semantics to clarify and the description correctly does not pad with nonexistent argument documentation.

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 (List) and resource (Capterra software categories) and enumerates the return fields (name, alias, canonical URL), making it distinguishable from sibling tools like run_capterra_category_products and run_capterra_products_search. It does not explicitly name or rule out those siblings, 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?

No explicit when-to-use context, prerequisites, or alternatives are given. The agent must infer from the name alone that this is the entry point for discovering Capterra categories before calling product-level siblings. Typical for this family but still a gap.

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

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

Annotations already declare read-only, idempotent, open-world, non-destructive behavior, so the safety profile is covered. The description adds genuinely new behavioral context beyond the schema and annotations: results are returned in Capterra's ranking order, and each returned record costs 1 point (a credit/cost disclosure). It omits pagination behavior, but the ranking and cost notes are real value-adds.

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, both front-loaded with the key facts (what it lists and how results are ordered, then the cost). Every clause earns its place with no filler.

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

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

There is no output schema, so the description carries the return-shape burden, and it does state that a ranked list of products comes back. Combined with full schema coverage and rich annotations, this is nearly complete; only pagination/response-detail specifics are 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 description coverage is 100%, so both the category (alias or URL) and max_items (up to 500, default 10) are fully documented in the schema. The description adds no further parameter syntax or format detail, so the baseline of 3 is appropriate.

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

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

The description gives a specific verb (List), resource (Capterra products), and scope (within a software category), which cleanly separates it from run_capterra_product (single) and run_capterra_products_search. It also states the ordering is Capterra's own ranking, a distinguishing trait. It does not explicitly name the sibling alternatives, keeping 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 phrase 'within a software category' implies you invoke this when you already have a category alias/URL, so usage is inferable. However, there is no explicit when-to-use vs. when-not, no guidance on how this differs from run_capterra_products_search or run_capterra_categories, and no prerequisites stated.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive). The description adds a genuinely new behavioral fact the annotations can't express: 'Flat 5 points per successful run,' which lets an agent weigh cost before invoking.

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

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

Two tight sentences, zero waste, with the resource and returned fields front-loaded and the cost note trailing. Nothing 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 single-parameter, fully documented lookup with full annotation coverage, the description supplies purpose, returned content, and cost. It only lacks a pointer to the search sibling for discovering ids.

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

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

Schema description coverage is 100% and documents the single 'product' parameter as an id or URL with an example. The description's 'by id or URL' merely restates 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 and resource ('Get full Capterra product details') and enumerates the returned content (vendor, pricing, ratings, features). The id-or-URL input frames it as a detail lookup, implicitly distinct from the search/reviews siblings, 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?

Implies an id or URL is required, which hints you must obtain one elsewhere, but gives no explicit when-to-use guidance and never routes the agent to run_capterra_products_search or run_capterra_category_products to find an id.

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

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

Annotations already cover read-only, idempotent, non-destructive, and open-world behavior. The description adds useful non-annotation context: the specific review fields returned and the fact that billing is '1 point per returned record,' which is important for an agent to know before invoking.

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

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

The description is two compact sentences: the core action and scope are front-loaded, followed by the essential cost behavior. Every phrase earns its place, with no filler or repetition.

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

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

For a simple two-parameter, read-only reviews tool with full annotation coverage and no output schema, the description covers purpose, returned fields, and billing. It could be slightly more complete by explicitly directing agents to use the product search tool first if they lack an id/URL, but otherwise it is sufficient.

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

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

Schema description coverage is 100%, with both parameters fully documented ('Product id or URL. e.g. 176586' and max_items up to 500, default 10). The description's 'by id or URL' reinforces the product parameter but adds no syntax or meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Get user reviews for a Capterra product by id or URL,' and explicitly lists the returned fields (rating, pros/cons, author). This clearly distinguishes it from sibling tools like run_capterra_product (product details) and run_capterra_products_search (product discovery).

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 'by id or URL' phrasing implies a prerequisite (a known product identifier), but the description does not explicitly say when to use this versus run_capterra_products_search or run_capterra_product. Usage is inferable, but there are no alternatives or exclusions named.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely non-schema behavior: '1 point per returned record', a billing/cost characteristic that directly affects how an agent sizes max_items. It stops short of describing pagination or result ordering.

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 sentences, zero filler, with the core action front-loaded and the cost note appended where it is most relevant. Nothing repeats the schema needlessly.

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

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

With no output schema, the description usefully enumerates the returned fields and notes the per-record cost, which is enough to call the tool correctly. The remaining gap is routing guidance among the Capterra siblings, which is a usage rather than completeness concern.

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 query and max_items (with its 1-250 range and 25 default) are already documented in structured form. The description only restates that the search is keyword-based, adding no syntax, matching, or ranking semantics. Baseline 3 applies.

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

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

The description names a specific verb and resource ('Search Capterra software products by keyword') and even previews returned fields (name, rating, review count, image). It does not, however, differentiate itself from close siblings like run_capterra_category_products or run_capterra_product, so an agent must infer the boundary.

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 or mention of alternatives, despite three closely related Capterra siblings (categories, category_products, product, products_reviews). The word 'keyword' implies free-text search, but the agent is left to guess that run_capterra_category_products is the browse-by-category 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds two things annotations cannot: the upstream data source (RUES/Registro Mercantil) and the cost model ('flat 5 points per successful run'), which is genuinely useful for an agent budgeting calls. It stops short of disclosing failure behavior or whether a URL and a NIT for the same company yield identical 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?

One front-loaded sentence carries purpose, source, keying method and the field inventory, followed by a short cost note. Nothing is redundant and nothing is buried; with no output schema present, the field enumeration is load-bearing rather than filler.

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

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

For a one-parameter read tool with no output schema, the description compensates well by naming the registry and listing the fields returned, so the agent knows what to expect. Gaps remain around miss/error behavior and the exact JSON shape, but these are minor given the tool's simplicity and the annotations covering side effects.

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

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

Schema description coverage is 100% with a single documented parameter including an example (899999068-1), so the schema does the heavy lifting. The description's 'by NIT or registry URL' mirrors the schema rather than extending it — it does not explain URL format, check-digit handling, or whether bare digits are acceptable. Baseline 3 is correct.

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 — fetch ONE Colombia company from the RUES/Registro Mercantil registry — and specifies the two accepted identifiers (NIT or registry URL). Enumerating the returned fields (name, status, registration date, address, legal form, economic activity, legal representation, establishments) makes the scope unambiguous versus the sibling run_co_companies_search.

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

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

Use case is implied: a single-record lookup keyed by NIT/URL, contrasted with the *_search sibling that takes free-text queries. However, the description never states when to prefer this over run_co_companies_search, nor what happens if the identifier is unknown or the company is not found. No 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?

Annotations already declare readOnly/openWorld/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new context: the underlying source registry (RUES) and the cost model ("1 point per returned record"), which is important behavioral information an agent cannot get from annotations. It stops short of describing pagination behavior or result caps.

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, with the core purpose and data source front-loaded and the cost note appended. The colon-list after "by name" is slightly ambiguous about whether those are search fields or returned fields, which is the only minor drag on structure.

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

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

With no output schema, the description usefully enumerates the return fields (name, NIT, status, chamber of commerce, category, link) and the source registry, while annotations carry the safety profile. Pagination and result-cap behavior are left entirely to the schema, which is a minor gap rather than a blocker.

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 (keyword, status, max_items, start_page) is already documented in the schema, setting the baseline at 3. The description's field list (NIT, chamber of commerce, category, link) actually reads as returned attributes rather than searchable inputs, adding little to parameter understanding.

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

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

States a specific verb and resource — searching the Colombia company registry (RUES, Registro Mercantil) by name — which clearly separates it from the non-search sibling run_co_companies. It does not, however, name or reference that sibling to make the split 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?

Usage is implied by "search ... by name" and the presence of a keyword parameter, but there is no statement of when to use this versus run_co_companies (lookup) or other country registry search tools, and no prerequisites or exclusions are given.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description nonetheless adds a genuinely behavioral detail annotations cannot convey: '2 points per returned record,' a cost signal an agent should weigh before paging. It stops short of stating rate limits or auth/credit-balance requirements.

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

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

Two dense sentences with zero filler; the core action and required key come first, followed by the returned fields, filters, and cost. Every clause carries information an agent uses when selecting or invoking the tool.

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

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

With no output schema, the description usefully enumerates the returned fields and notes pagination and per-record cost, which is what an agent needs to plan a call. It could add how to construct/validate the LinkedIn URL or what happens at page boundaries, but nothing essential is missing for correct invocation.

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

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

Schema description coverage is 100% and each parameter already carries type, range and example values, so the baseline is 3. The description restates the filter axes (seniority, department, country) and pagination without adding format nuance, edge-case behavior, or how the comma-separated country string differs from the array-typed job_level/job_function 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?

A specific verb and resource ('Find the employees of a company') plus an enumerated set of returned fields (name, headline, title, seniority, department, location, profile, skills, education) makes the tool's function unambiguous. However, it never distinguishes itself from the near-identical siblings run_linkedin_company_employee and run_linkedin_people_search, so an agent still has to guess which one to pick.

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

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

'Filter by seniority level, department and country; page through large companies' gives practical invocation context, and the required LinkedIn-URL key is implied. But there is no explicit when-to-use/when-not guidance and no naming of the competing LinkedIn employee/people-search siblings, so the routing decision is left 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds value beyond them by disclosing the cost model ('Flat 5 points per successful run') and the approximate result size (~700 sites), which an agent cannot learn from structured fields.

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

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

Two tightly packed sentences: the resource and its fields come first, then the cost note. No filler or restated name/title.

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

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

With one optional parameter, no output schema, and annotations covering behavior, the description is nearly complete — it even lists the returned fields, substituting for a missing output schema. A note on ordering or whether results are paged would close the remaining 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% and the single optional 'country' parameter is documented in the schema itself with an example. The description adds no additional semantics about the filter 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 states a specific resource ('Directory of ~700 Craigslist regional sites') and enumerates the fields returned, which is concrete and non-tautological. It doesn't explicitly distinguish itself from siblings like run_craigslist_categories or run_craigslist_postings_search, though the 'areas' scope is fairly self-evident.

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

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

Usage is only implied: the parenthetical 'the alias value for searches' hints that this is a lookup to obtain area values for the postings search tools, but it never says when to call this versus run_craigslist_categories or the postings tools, nor any 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?

Annotations already declare the safe read-only, idempotent, non-destructive profile, so the burden is lower. The description adds genuinely new behavioral context not present in annotations: the flat 5-point cost per successful run, which lets an agent judge budget impact before calling.

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 no filler; the output content is front-loaded and the cost note follows. Every clause carries information.

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

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

With no output schema, the description correctly enumerates what is returned (alias, description, section) and notes the cost. Minor gap: 'Every ... category' reads as unconditional while the schema offers an optional section filter, leaving the filtering behavior slightly ambiguous.

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

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

Schema description coverage is 100% and the single 'section' parameter is a fully enumerated list with human-readable labels, so the schema carries the load. The description does not clarify the optional section filter at all (its use of 'section' refers to a returned field), so a baseline 3 is appropriate.

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

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

States a specific resource (every Craigslist posting category) and what each entry contains (alias, description, section), so an agent knows this is a reference/catalog lookup rather than a listing fetch. It does not explicitly name sibling tools such as run_craigslist_postings_search, though 'the category value for searches' hints at the relationship.

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 'the category value for searches' implies this tool exists to supply category values to the search tool, but there is no explicit when-to-use/when-not statement or named alternative. Usage must be inferred.

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

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

Annotations already declare readOnly=true, idempotent=true and non-destructive, so the safety profile is covered. The description adds genuinely new context beyond that: the exact content returned (decoded VIN spec, hiring company, category attributes with matching filters) and the cost model ('Flat 5 points per successful run'), which is information an agent cannot get from the schema or annotations.

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

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

A single dense sentence front-loads the essential verb and identifier, then lists return fields and pricing with no filler. The field enumeration is long but each entry conveys real payload information, so it is not padding.

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

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

For a single-record fetch with no output schema, the description usefully enumerates what comes back, and annotations plus the stated cost round out the operational picture. Pagination is irrelevant for an ID lookup, leaving only minor gaps such as behavior on a stale or deleted posting.

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

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

With one parameter at 100% schema coverage, the schema already documents that 'posting' accepts a 22-character ID or URL including an example. The description restates 'by id or URL' without adding format, normalization, or error-behavior detail, so the baseline 3 applies.

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

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

States a clear verb+resource ('Full Craigslist posting by id or URL') and enumerates the payload fields (title, price, body, VIN spec, hiring company, images, location, dates), which distinguishes it from generic searches. It does not name the sibling run_craigslist_postings_search or run_craigslist_postings_seller to make the detail-vs-list distinction explicit, 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 'by id or URL' constraint implies this is a single-record fetch rather than a search, but there is no explicit when-to-use/when-not guidance or named alternative. The 'Flat 5 points per successful run' line gives a useful cost signal that informs the decision, but routing between this and the *_search / *_seller siblings is left to inference.

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

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

Annotations already declare readOnly/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds two non-annotation facts: results are 'live' (real-time sourcing) and each returned record costs 1 point, a metering detail the agent needs before calling.

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

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

Two sentences, front-loaded with the verb and resource, that stay compact despite covering a 67-parameter tool. It is dense but every clause (filters, return fields, cost) carries information.

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

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

For a high-complexity tool with 67 params and no output schema, the description usefully names the returned fields (title, price, date, location, images, facets) and the cost model. Pagination controls (start_page, max_items) are left to the schema, which is acceptable but is the main residual 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%, so baseline is 3, but the description adds a filter taxonomy that the schema does not express: it groups the 60+ filters into vehicle/motorcycle/boat/housing/job/gig/event families and names the geo inputs (area/sub-area/postal/coordinates). This helps an agent reason about which parameter family to reach for.

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 resource ('live Craigslist postings') and enumerates the scope of what can be searched (keyword, category, geo, 60+ filters). It also lists return fields. It does not explicitly distinguish itself from sibling run_craigslist_postings or run_craigslist_postings_seller, 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?

Usage is implied by the name and the 'any regional site' framing, and the billing note ('1 point per returned record') is a useful cost signal for deciding to call it. However, there is no explicit when-to-use/when-not guidance or named alternative sibling (e.g., postings lookup vs. seller postings).

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

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

Annotations already establish read-only, idempotent, open-world, and non-destructive behavior. The description adds useful non-obvious context: it returns the seller's full inventory and costs 1 point per returned record, which is important for budgeting tool calls.

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

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

It is two compact sentences with no filler. The core purpose is front-loaded and the billing note follows immediately, making the most important information easy to scan.

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

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

For a read-only listing tool with a fully described schema and no output schema, the description covers the return concept (seller's postings) and the cost model. It could mention pagination behavior or explicitly route to alternatives, but it is largely complete for correct invocation.

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

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

Schema description coverage is 100%, so the five parameters are already well documented in the input schema. The description only refers to the required posting input and does not add semantics for sort, category, max_items, or start_page.

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

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

The description clearly states the resource: all postings published by the seller of a given Craigslist posting, and gives concrete seller types (dealer, landlord, shop). It distinguishes itself from generic posting search or lookup siblings by scope, but does not explicitly name an alternative 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 use case is implied: retrieve a seller's full inventory from a known posting. However, it does not say when to prefer this tool over run_craigslist_postings_search or run_craigslist_postings, and no exclusions or prerequisites are stated.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is fully covered. The description adds the set of fields returned, which is useful, but discloses nothing about auth requirements, rate limits, or failure behavior for an invalid URL. With annotations carrying the safety burden, this is adequate but not rich.

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; the verb and resource come first and the returned fields follow compactly in parentheses. 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 one-parameter, 100%-covered tool with full annotations and no output schema, the description is largely sufficient and the field enumeration usefully substitutes for a missing output schema. The only real gap is the absence of any routing hint among the many sibling company-lookup 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% and the schema supplies a concrete example URL, so parameter documentation is already complete. The description only restates that input is a Crunchbase company URL, adding no format or constraint detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb (fetches), resource (structured company data), and source (a Crunchbase company URL), with an explicit enumeration of returned fields. It is clear what the tool does, though it never distinguishes itself from the many similar company-lookup siblings (run_owler_companies, run_pitchbook_companies, run_tracxn_companies) that overlap in purpose.

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

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

No when-to-use guidance and no alternatives named. It doesn't say how to obtain a Crunchbase URL or when Crunchbase is preferable to the other company-data providers in the sibling list. The agent is left to infer usage entirely.

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

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

Annotations already cover read-only, idempotent, open-world and non-destructive behavior, so the description is not burdened with safety disclosure. It adds genuinely new behavioral context: the accepted identifier prefix families (HE, EE, AE, S, BN) and a cost of '10 points per returned record', which the agent needs before calling. It does not say what happens on an unknown or malformed 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?

One front-loaded sentence that opens with the verb and resource, then lists the payload and the credit cost; nothing is redundant. It is dense and long for a single sentence, but every clause carries information, and the cost note is well placed at the end.

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

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

With no output schema, the description correctly enumerates the return fields (name, status, dates, officers, annual fees, counters), so an agent can judge result fitness, and it discloses credit cost. The remaining gap is not distinguishing this lookup from the sibling search/filings tools in a Cyprus registry cluster this large.

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 a baseline of 3 would be defensible, but the description goes beyond the schema's 'Registration number or registry URL' by naming the valid Cyprus prefix families (HE, EE, AE, S, BN) and explicitly accepting a registry link. That meaningfully reduces the chance of passing an unusable identifier.

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 ('Get one organisation from the Cyprus registry') and enumerates the returned data fields, which makes the tool clearly a single-record lookup rather than a list. It signals 'one' record, implicitly contrasting with the sibling search tool, but never names run_cy_companies_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?

The identifier-based lookup ('by registration number ... or registry link') implies when to use it versus a name-based search, but that routing is left to inference. There is no explicit statement of when to prefer run_cy_companies_search or run_cy_company_filings instead, and no mention of prerequisites such as a valid Cyprus registration 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful cost and source context ('1 point per returned record', DRCOR) but omits behavioral details like pagination, rate limits, or authentication requirements.

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

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

Two short sentences, front-loaded with the action and source before the cost note. Every sentence earns its place and there is no redundant or vague filler.

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

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

For a simple read-only search tool with rich annotations and full schema coverage, the description supplies source, search field, returned fields, and cost. It is nearly complete, missing only explicit routing versus the detail-oriented sibling run_cy_companies.

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 in the input schema. The description reinforces only the 'by name' aspect of the keyword parameter and adds no syntax, format, or constraint details beyond what the schema provides, matching 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?

States a specific verb (Search) and resource (Cyprus company registry / DRCOR) with scope 'by name', and lists returned fields. It does not explicitly distinguish itself from sibling tools such as run_cy_companies or other country-specific search tools, 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?

The description only says to search the Cyprus registry by name; it gives no when-to-use guidance, no when-not-to-use conditions, and no alternatives such as run_cy_companies for detailed company data. The implied usage is clear but unstated as guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely new behavior: a cost model ('1 point per returned record') and the shape of returned records ('with form, date and page number'), which helps the agent reason about cost and output.

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

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

Two sentences, no filler, front-loaded with verb and resource; the cost sentence earns its place. The first sentence is dense with category enumeration, which is useful but slightly reads as a run-on.

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

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

With no output schema, the description compensates by naming the fields returned (form, date, page number) and the record categories. What is missing is pagination context for start_page/max_items and the point limit, but for a read-only listing tool this is largely 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 all four parameters including the list enum meanings and the company example. The description restates the enum options and the identifier accepted, adding only marginal meaning. 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 ('List') and resource ('the filings of one Cyprus organisation'), names the authoritative source (Registrar of Companies, DRCOR), and enumerates the filing categories. An agent can distinguish it from run_cy_companies / run_cy_companies_search without opening either schema.

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

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

The description implies the tool is used once a company has been identified ('by registration number or registry link'), and the list enum values define the kinds of filings to request. However, it never states when to prefer this over run_cy_companies, nor any prerequisites (e.g. that a registry link can substitute for a number). Usage is implied rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds real value beyond them: it discloses cost ('5 points per returned record') and enumerates the returned data set. It does not say what happens when the IČO is not found or invalid, which is the remaining behavioral gap.

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

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

Two sentences, no filler: identity of the source and identifier first, then the returned payload and the credit cost. Each 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?

For a one-parameter, annotated, read-only lookup with no output schema, the description covers input forms, source and returned fields, which is nearly everything needed. Only the not-found/error behavior and whether the URL must be a Justice.cz URL are left 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 coverage is 100% and the schema already gives an example, so baseline is 3. The description adds meaning on top: it states the IČO is 8 digits and that the alternative input is a registry URL, tightening the accepted format beyond the bare schema description.

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 (get one company from the Czech Republic commercial register), names the source (Justice.cz), and pins the identifier (IČO, 8 digits, or registry URL). The enumerations of returned fields make it clearly a single-record enrichment lookup, distinguishable from the paired search/filings siblings.

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

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

The 'one company ... by registration number or URL' framing makes the single-record use case clear, implicitly ruling out listing/paging work. However, it never names run_cz_companies_search or run_cz_company_filings as the alternatives when the caller only has a name or wants filings.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile needs no restating. The description adds genuinely new behavioral context: the upstream source (Justice.cz) and the per-record credit cost, which is not captured by any structured field.

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

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

Two compact sentences, front-loaded with the search scope and followed by the cost note. No filler or repetition; slightly denser field listing could be trimmed, but every element carries information.

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

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

With no output schema, the description usefully enumerates the returned fields (name, IČO, status, address, link), which is exactly the information an agent needs to judge usefulness of results. Combined with the cost note and source, it is complete for a read-only 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 coverage is 100%, with each of the four parameters described in the schema including the status enum and max_items default. The description only reiterates the name keyword, so it adds nothing beyond the schema and the baseline 3 applies.

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

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

States a specific verb (Search), the exact resource (Czech Republic commercial register, Justice.cz), and the lookup key (company name), which contrasts with the sibling run_cz_companies lookup tool. It also enumerates the returned fields. It stops short of naming a sibling explicitly, so differentiation is inferential 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?

Usage is implied by 'search ... by company name', telling the agent this is a name-based query tool, and the cost note ('1 point per returned record') hints at frugality. However, there is no explicit when-to-use vs when-not guidance and no reference to run_cz_companies or run_cz_company_filings as 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive behavior, so the safety profile is covered. The description adds genuinely useful context beyond that: the authoritative source (Sbírka listin, Justice.cz), the 'newest first' ordering, and the cost signal '1 point per returned record'. It omits auth requirements and pagination/rate-limit behavior, keeping it short of a 5.

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

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

A single, front-loaded sentence that opens with the verb and resource before trailing into the field list. Dense but free of filler; the only mild weakness is that the colon-separated field enumeration makes the sentence long, but each element carries information.

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

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

There is no output schema, so listing the returned fields (document number, type, description, period, filing dates, pages, link) is a valuable and necessary addition. Combined with annotations covering safety and 100% schema coverage on inputs, the definition is nearly complete; only pagination interplay between start_page and max_items is left unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents 'company' (IČO or registry URL), 'max_items' and 'start_page'. The description echoes the accepted identifier forms but adds no new syntax or semantics for the pagination parameters, so the baseline of 3 applies.

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

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

The description gives a specific verb ('List') and resource ('documents filed in the Czech Republic Collection of Documents') scoped to 'one company', and even enumerates the returned fields. This is far more precise than a bare name restatement. It does not, however, explicitly contrast itself with the many sibling tools (e.g. run_cz_companies, run_cz_companies_search), so the differentiation is only implicit.

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 that you call it with a single company identifier to retrieve that company's filings. There is no explicit when-to-use/when-not guidance and no named alternative (e.g. run_cz_companies_search for finding the company first), leaving routing to inference.

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

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

Annotations already establish read-only, idempotent, open-world, non-destructive behavior, so the bar is lower. The description nevertheless adds two genuinely useful facts beyond structured data: that Dealroom returns ranges rather than exact values without a login, and that each successful run costs a flat 5 points. That is meaningful cost and data-quality 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?

Front-loads the core action in the first clause, then lists what is returned, then closes with two compact caveats. The field enumeration is long but functional; 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 no output schema, the field list ('tagline, HQ, founding year, sector, tier, valuation / revenue / headcount ranges, investors by round...') usefully compensates by describing the return shape. Combined with the data-range caveat and cost note, an agent has enough to call this correctly; only the search alternative remains 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 coverage is 100% and the schema already gives the slug/URL example 'revolut'. The description repeats that the parameter accepts a slug or URL but adds no extra format, normalization, or error-handling detail. Baseline 3 is appropriate when the schema 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?

States a specific verb and resource ('Get one company from Dealroom') and enumerates the returned fields. The 'one company ... by slug or URL' phrasing implicitly separates it from run_dealroom_companies_search, but the sibling is never named, so the differentiation is inferential rather than explicit.

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

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

Accepts slug or URL, which implies a lookup-by-identifier use case rather than a discovery use case, but the description never says when to prefer this over run_dealroom_companies_search or what to do when you only have a company name. Usage is implied only.

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