NeuralVerge Business Intelligence

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

No annotations are provided, so the description carries the full burden. It does disclose a real behavioral trait — a flat 5-point cost per successful run — which is genuinely useful for an agent budgeting calls. However, it says nothing about failure behavior, retries, or auth/prerequisite 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 front-loaded sentences with zero filler: the first states exactly what is returned, the second states the cost. Nothing is repeated from the name or schema.

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

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

With no output schema and no annotations, the description partially compensates by enumerating the returned field groups and disclosing the credit cost. It remains silent on error handling and whether the identifier can be from any Alibaba locale, but for a single-param detail lookup it 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?

There is a single parameter with 100% schema description coverage ('Product ID or URL. e.g. 1601022319019'), so the schema already carries the semantics. The description's 'by ID or URL' merely echoes it without adding format or validity constraints, making the baseline 3 appropriate.

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

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

States a specific verb ('Get full ... details') and resource ('Alibaba product') and enumerates the returned field groups (price tiers, MOQ, attributes, variants, supplier). It distinguishes itself from a search tool by requiring an ID or URL, though it never names run_alibaba_product_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 'by ID or URL' phrasing implies this is a detail-lookup tool used after you already have a product identifier, but it offers no explicit when-to-use guidance or named alternative for discovery flows. Usage is inferable from the sibling set 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?

With no annotations, the description carries the full behavioral burden. It does disclose a meaningful operational trait — '1 point per returned record' — which is useful cost/rate-limit context an agent can act on. However it says nothing about result limits beyond the schema, pagination, or whether the search is a plain read, leaving notable gaps.

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

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

Two compact clauses with the search scope front-loaded and the cost note appended; nothing is wasted. It is appropriately sized for a simple two-parameter search tool.

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

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

For a simple search tool with no output schema and no annotations, the description gives the searched resource, the returned fields, and the cost model, which is reasonable coverage. It stops short of stating limits, pagination behavior, or how results are ordered, leaving the agent to infer those.

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

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

Schema description coverage is 100% for the two parameters (keyword with an example, count with default and max), so the schema already documents everything. The description adds no syntax, format, or filtering nuance beyond the schema, making the baseline 3 appropriate.

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

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

Names a specific verb (search) and resource (Alibaba products) and lists the returned data domains (price, MOQ, supplier, certifications), which tells an agent what it will get back. It does not explicitly contrast with the sibling run_alibaba_product, but the platform+verb combination is distinctive enough to separate it 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: nothing says when to prefer this over run_alibaba_product or over the other marketplace search siblings (aliexpress, amazon, etc.). The only usage-adjacent information is the billing note, which tells the agent cost, not selection criteria.

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

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

No annotations are provided, so the description carries full behavioral burden. It usefully discloses the cost model ('Flat 5 points per successful run'), which is real value-add, but says nothing about auth, rate limits, failure modes, or whether missing products error vs. return empty.

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, zero waste, with the core action front-loaded and the cost note placed after. Nothing redundant or padded.

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

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

With no output schema, the description helpfully names what is returned (title, price, images, store) and discloses cost. Remaining gaps (error behavior, currency/language defaults) are minor for a simple 3-param 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 includes a worked example ('1005012791281455') plus full enum value listings, so the schema does the heavy lifting. The description adds no parameter-level detail beyond identifying that lookup is by ID.

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 AliExpress product details by ID') and enumerates the returned fields (title, price, images, store). The 'by ID' phrasing implicitly separates it from run_aliexpress_product_search, but no sibling is named explicitly.

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

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

No when-to-use guidance, prerequisites, or named alternatives. The agent must infer from the name/inline 'by ID' that this is the single-product lookup versus the search sibling.

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

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

With no annotations, the description carries the full burden, and it usefully discloses cost behavior ('1 point per returned record') plus the shape of returned data. However it omits pagination, auth, or rate-limit behavior, leaving meaningful gaps for a paid data-retrieval call.

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

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

Two tight sentences, front-loaded with purpose and free of boilerplate. Every clause carries information, though it is deliberately terse rather than rich.

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

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

No output schema and six parameters, so the description must do more; it names the returned fields and the points cost, which is helpful, but says nothing about ordering, pagination, or result volume behavior. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents product, filter, currency, language, max_items, and translate. The description only echoes the product-ID usage, adding nothing beyond what the schema provides; 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 buyer reviews for an AliExpress product by ID') and previews the returned fields (rating, text, buyer details). The platform name distinguishes it from the many other *_reviews siblings, though it does not explicitly name a sibling it is not.

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

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

No when-to-use guidance, no exclusions, and no pointer to alternatives such as run_aliexpress_product or the search tool. The agent must infer that this is the right tool purely from the name and platform.

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

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

With no annotations, the description carries the full burden. It usefully discloses the cost model ('1 point per returned record'), which is real behavioral context an agent should weigh. However, it omits pagination behavior (start_page/max_items are undocumented in the description) and any rate-limit or return-shape caveats.

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, zero filler, with the core purpose front-loaded before the cost note. Everything stated 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 15-parameter search tool with no annotations and no output schema, the description is thin: it briefly names return fields but gives no pagination, result-volume, or filtering guidance. Cost is covered, but an agent would need the schema to fully operate it.

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

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

Schema description coverage is 100%, so all 15 parameters are already documented in the schema (enums, defaults, min/max). The description adds no parameter-level detail beyond the schema, which is the expected baseline for a fully documented schema.

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

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

States a specific verb (Search) and resource (AliExpress products) with the key input dimension (by keyword) and a brief hint at returned fields. It is clearly distinguishable from run_aliexpress_product_reviews, though it does not explicitly differentiate itself from the sibling run_aliexpress_product (detail lookup).

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

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

The phrase 'by keyword' implies the tool is for keyword-driven discovery, but there is no explicit when-to-use guidance, no statement of when to prefer run_aliexpress_product instead, and no mention of prerequisites or limitations. Usage is only inferable.

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

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

No annotations are provided, so the description carries the full burden. It does add genuinely useful behavioral context by disclosing the cost model ('Flat 5 points per successful run'), which structured fields do not convey. However, it says nothing about authentication needs, failure behavior for invalid ASINs, or rate limits.

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

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

Two short sentences with zero waste. The returned-field enumeration and the key are front-loaded, and the cost note is a compact second sentence.

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

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

With no output schema, the description usefully enumerates the fields returned (title, brand, price, images, rating, features, seller) and discloses cost, which covers most of what an agent needs. It is a bit thin on the multi-domain behavior and any error/pagination 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 the ASIN format example and the full domain enum with default are already documented in the schema. The description only reinforces the ASIN key and omits the domain parameter entirely, so it adds little beyond the schema baseline.

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

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

States a specific verb and resource ('Get full Amazon product details'), names the lookup key (ASIN), and enumerates the returned fields. 'By ASIN' implicitly distinguishes it from the sibling run_amazon_product_search, but it never explicitly names that alternative or run_amazon_product_offers.

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 'by ASIN' framing tells an agent this is a direct-lookup tool rather than a search tool, but there is no explicit when-to-use statement, no prerequisites, and no named alternative for the search/offers siblings.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses cost ('Flat 5 points per successful run'), which is genuine behavioral context beyond the schema, but omits auth requirements, pagination, rate limits, or what happens on an invalid ASIN.

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 waste; the purpose and returned fields are front-loaded before the cost note. Every sentence earns its place.

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

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

There is no output schema, and the description partially compensates by listing the returned fields (price, condition, seller, delivery). For a 2-parameter tool with a fully documented schema, this is nearly complete, with only minor gaps around result volume or pagination.

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

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

Schema description coverage is 100%, so the baseline is 3. The description references ASIN and the returned fields but adds no syntax, format, or default detail (e.g., the domain default) beyond what the schema already provides.

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

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

States a specific verb ('Get'), resource ('all marketplace offers for an Amazon product'), and the key it operates on ('by ASIN'), plus the fields returned (price, condition, seller, delivery). This implicitly distinguishes it from run_amazon_product (product details) and run_amazon_product_search, though it never names a sibling to differentiate explicitly.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative tool is named. An agent must infer that this tool is for fetching competing offers on a known ASIN rather than product metadata or search, which is not stated.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses a cost model ('1 point per returned record') and pagination behavior, but says nothing about auth requirements, rate limits, or bounds on returned data beyond the 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?

Two short sentences with zero filler; the extracted-field list and cost notice are front-loaded and immediately actionable.

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

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

For a search tool whose parameters are fully documented by the schema, the description adequately covers scope and result contents, and supplements the missing output schema by naming returned fields plus the cost per record. Only the absence of sibling routing keeps it from being fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including the domain enum and item bounds. The phrase 'across paginated results' hints at start_page/max_items behavior but adds little beyond the schema.

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

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

States a specific verb (search/extract) and resource (Amazon product listings) and enumerates the returned fields. It implicitly distinguishes itself from siblings like run_amazon_product (single-item detail) and run_amazon_product_offers, but never names them explicitly.

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

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

No when-to-use or when-not-to-use guidance and no mention of alternatives such as run_amazon_product for detail lookups. Usage is only implied by the tool name and the word 'search'.

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

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

With no annotations, the description carries the full burden. It adds real value by disclosing cost ("Flat 5 points per successful run"), which annotations would not cover. However, it omits whether the operation is read-only, what happens on an invalid seller ID, and any rate-limit or auth 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 with zero waste: purpose and return fields first, cost second. Nothing redundant or padded.

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

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

For a two-parameter read tool with no output schema, the description covers purpose, inputs, cost, and the shape of the returned profile. It lacks only explicit alternative routing and failure behavior, which are minor for a straightforward lookup.

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

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

Schema coverage is 100%, so both the seller ID and the domain enum are fully self-documenting in the schema. The phrase "by seller ID" merely points at the seller parameter without adding format or validation detail. Baseline 3 is appropriate.

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

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

States a specific verb and resource ("Get an Amazon seller profile by seller ID") and enumerates the returned fields (name, rating, business details, contact info). This distinguishes it from run_amazon_seller_products by scope, but it never explicitly names that sibling, so the 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?

The description identifies the required input (a seller ID) but gives no when-to-use guidance, no prerequisites, and no routing to alternatives like run_amazon_seller_products or run_ebay_seller. Usage must be inferred entirely from the verb and field list.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a real behavioral trait in '1 point per returned record', which tells the agent about cost scaling with max_items, but it omits auth requirements, pagination behavior, and any failure modes.

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

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

Two short sentences, zero filler, with the resource and return fields front-loaded before the cost caveat. 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?

With no output schema, listing the returned fields is valuable and it adds the point-cost model. It falls short on pagination semantics (how start_page and max_items interact across the 250-item cap) and on how to obtain a seller ID, but nothing critical for a simple read tool is missing.

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

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

Schema description coverage is 100%, so domain, seller, max_items, and start_page are already documented with defaults and bounds. The description adds no parameter-level detail; the cost note only loosely connects to max_items. 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 ('List products sold by an Amazon seller's storefront') and enumerates the returned fields (title, URL, price, rating, image). This clearly separates it from run_amazon_product (single product) and run_amazon_seller (seller profile) among the siblings.

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

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

Usage is only implied by the phrase 'sold by an Amazon seller's storefront' – the agent can infer it takes a seller ID and returns that seller's catalog. No explicit when-to-use, when-not-to-use, or named alternatives (e.g. run_amazon_seller, run_amazon_product_search) 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the cost model ('5 point per returned record') and enumerates the returned fields, which is real behavioral context. It does not cover auth requirements, what happens on an invalid/unknown CUIT, rate limits, or whether lookups are cached.

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 identity of the resource and its source, with the returned-field list and pricing trailing. The field enumeration is longish but each item is informative, and nothing is repeated.

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

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

With no output schema and no annotations, the description compensates by listing the fields returned (name, company type, contract date, addresses, activities, last update) and the cost. Missing only failure-mode behavior (not found, invalid CUIT), which keeps it short of fully complete for an unannotated 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 schema already documents the single 'company' parameter with an example CUIT. The description's phrase 'by CUIT or registry link' mirrors that, so it adds no syntax or format detail beyond the structured field; 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?

Names a specific verb and resource ('Get one company from the Argentina registry of legal entities') and identifies the authoritative source (IGJ / Registro Nacional de Sociedades) plus the exact lookup keys. It implies the single-record nature of the call, but never names the sibling run_ar_companies_search, so the differentiation from the search variant is left to inference.

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

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

The input framing ('by CUIT or registry link') implies this is a point lookup rather than a browse/search operation, which is reasonable implied guidance. However there is no explicit when-to-use statement and no mention of run_ar_companies_search as the alternative when the user only has a name rather than an identifier.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses billing behavior ('1 point per returned record') and the read-only nature is implied by 'Search', but it says nothing about rate limits, pagination behavior, or permission 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 sentences, front-loaded with the verb and resource, and the returned-field list and cost note are compact. Slightly dense with the field enumeration, 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?

With no output schema, listing the returned fields (name, CUIT, type, address, activity, link) and the per-record cost fills important gaps. All four parameters are documented in the schema. Missing only pagination/empty-result behavior, which keeps it short of 5.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema by stating that CUIT can be used as a search key, whereas the keyword schema description only mentions 'Company name'. This is a genuine semantic addition.

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 the Registro Nacional de Sociedades/IGJ), and lists the returned fields. It does not explicitly distinguish itself from the sibling run_ar_companies, so an agent must infer the search-vs-lookup split.

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?

Says the search is performed 'by company name or CUIT', which implies the intended input context, but gives no when-to-use guidance, no exclusions, and no pointer to run_ar_companies for single-entity retrieval. 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?

With no annotations, the description carries the full burden. It does add genuinely useful behavioral detail: the flat 5-point cost per successful run and the note that paid extracts are offered. However, it says nothing about failure behavior, whether a missing FN errors or returns empty, or any auth/rate constraints.

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

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

Front-loaded with the core action and identifier, followed by the returned fields and cost. Two sentences, no padding; the cost sentence earns its place by informing budget-aware agents, though the field list is somewhat compressed.

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, status, legal form, address, previous names, extracts), which is exactly what the agent needs. It is only slightly incomplete on error/empty-result behavior for an unknown FN.

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 'company' parameter is already documented as 'Registration number (FN) or registry URL. e.g. 56247t'. The description restates the same semantics, so the baseline 3 applies with no added value.

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 from the Austria Firmenbuch registry), and the accepted identifier (FN or registry URL). This clearly separates it from the sibling run_at_companies_search, which handles lookup-by-name rather than a direct single-record fetch.

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 'Get one company ... by registration number (FN) or registry URL' implies the usage context (you already have an identifier), but the description never names the alternative search tool or states explicitly when not to use this one. 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the billing trait ('1 point per returned record') and the retrieved fields, which is valuable behavioral context beyond the schema, but it omits auth needs, rate limits, and pagination 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, tight sentence with an inline colon list of return fields and a trailing cost note. Purpose and cost are front-loaded with no wasted text.

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

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

With no output schema, the description helpfully enumerates the returned fields, and it names the registry and cost model. It is nearly complete, missing only pagination semantics and the relationship to its 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 description coverage is 100%, so the four parameters are already documented. The description only reinforces the 'company name or FN' input mapping and adds no syntax or format detail beyond the schema, which is the baseline-3 situation.

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

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

States a specific verb and resource ('Search the Austria company registry (Firmenbuch)') plus the search keys ('by company name or FN') and the fields returned. It is clear what the tool does, but it never distinguishes itself from the sibling run_at_companies (the direct-lookup counterpart) or the many other country 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 explicit when-to-use, when-not, or alternative guidance. The mention of searching 'by company name or FN' implies a keyword input but does not tell the agent when this search entry point is preferable to run_at_companies.

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

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

No annotations are provided, so the description carries the burden. It does disclose the returned fields and the pricing model ('Flat 10 points per successful run'), which is useful behavioral context. It does not cover auth requirements, rate limits, or error/not-found behavior, so gaps remain for a tool with zero annotation coverage.

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 scoped sentences: the first front-loads purpose, identifiers and outputs; the second adds the cost model. No filler or redundant restatement of the name.

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

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

For a simple one-parameter lookup with no output schema, the description compensates by enumerating the returned fields (name, status, registration date, address, legal form) and the cost. It is nearly complete; only failure-mode behavior and access prerequisites are 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?

With a single parameter at 100% schema description coverage, the schema already documents the 'company' field and gives an example. The description restates the accepted forms (registration number or registry URL) but adds no format or validation nuance 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 Australia registry'), names the registries (ASIC / ABN), the accepted identifiers (registration number or registry URL), and enumerates the returned fields. The 'one company' framing cleanly contrasts with the sibling run_au_companies_search without needing to name it.

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

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

Usage is implied rather than stated: the tool takes a specific identifier, so an agent can infer it is for a known company versus the search sibling. There is no explicit when-to-use / when-not-to-use statement or named alternative, leaving the routing to run_au_companies_search to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the cost model ('1 point per returned record'), which the schema does not, but says nothing about pagination behavior, auth/permission requirements, or rate limits for a read tool.

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

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

A single front-loaded sentence that states the registry, the query dimension, and the returned fields with zero filler.

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

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

With no output schema, the description helpfully enumerates the returned fields, covering the main gap. It is nearly complete, though pagination semantics implied by start_page/max_items are 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 the schema already documents keyword, status, max_items, and start_page. The description reinforces the name-based keyword lookup but adds no syntax, format, or matching-semantics detail beyond what the schema supplies.

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

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

States a specific verb (Search) and resource (Australia company registry ASIC/ABN) and enumerates the fields returned (name, registration number, status, address, link). It does not explicitly differentiate itself from the sibling run_au_companies, leaving the search-vs-detail distinction to inference.

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

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

There is no when-to-use guidance and no mention of alternatives. With run_au_companies and ~40 other country search siblings present, the description never says to use this one for discovery versus the detail tool for a known entity.

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

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

With no annotations, the description carries the full burden. It usefully discloses the cost model ('5 point per returned record') and the returned fields, but it omits auth requirements, rate limits, and any explicit side-effect or safety note beyond the implied read-only 'Get'.

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: the first front-loads the operation and result fields, the second states the cost. No filler, no restating the tool name, and the important billing detail is not buried.

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

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

For a zero-param tool with no output schema, the description adequately explains the return shape (id, name, alias, parent id, level, browse URL) and cost. It could be slightly stronger by stating that the tree is returned in full and whether pagination applies, but it is otherwise complete.

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

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

There are zero input parameters, so the baseline is 4. The description correctly needs no parameter-level explanation, and the empty schema is consistent with a no-argument category-tree fetch.

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.' It also names the returned entities ('departments and sub-categories'), which cleanly separates it from sibling item/seller tools such as run_avito_items and run_avito_sellers.

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 prerequisites, and no alternative tools. It does not say whether this should be called before category-filtered item searches, nor how it relates to other Avito category-capable siblings.

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

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

With no annotations provided, the description carries the full behavioral burden. It helpfully discloses the return payload fields, the price currency (RUB), and the cost model ('Flat 5 points per successful run'), but it does not state that the operation is read-only, mention authentication requirements, rate limits, or error behavior. This is adequate for a simple read endpoint but leaves clear gaps.

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

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

The description is two tight sentences: the first front-loads purpose and enumerates return fields, while the second supplies the pricing behavior. No sentence is wasted, and the critical identifier scope ('by id or URL') appears before the field list.

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

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

For a one-parameter getter with no output schema and no annotations, the description does what is needed: it identifies the required input shape, lists the returned data categories, and states the cost. It stops short of describing error cases or confirming read-only safety, but the core information an agent needs to call and interpret the tool is present.

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

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

Schema description coverage is 100%, and the single parameter 'item' is already documented as a 'Listing ID or URL. e.g. 8132133298.' The description echoes 'by id or URL' but adds no syntax, format, or constraint detail beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Get a full Avito listing by id or URL,' and enumerates the returned fields. This clearly distinguishes it from a generic search or seller endpoint in substance, but it never names the sibling search tool (run_avito_items_search) or explicitly contrasts this lookup-by-id/URL behavior with searching. Thus it is clear but lacks explicit 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?

The condition 'by id or URL' implies the tool is for direct lookups when an identifier is already known, and the sibling run_avito_items_search covers query-based discovery. However, the description never states when to prefer this tool over search, categories, or sellers, nor does it mention any exclusions. Usage is therefore only implicitly indicated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context by stating the flat cost ('Flat 5 points per successful run') and the fields returned. However, it does not disclose authentication needs, rate limits, error behavior, or whether the operation is strictly read-only, leaving significant gaps for an annotation-free tool.

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

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

The description is a single efficient sentence, front-loading the action and resource, then listing returned fields and cost. Every element earns its place and there is no redundancy 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?

Given the simple read-only nature, full schema coverage of the lone parameter, and the absence of an output schema, the description is nearly complete: it explains the input method and enumerates the return fields. It falls short only by omitting any operational context such as failure modes or rate limits, but those are arguably minor for this tool type.

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

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

Schema description coverage is 100% and the single parameter already includes a description and example ('Brand slug or URL. e.g. steve'). The tool description repeats the 'slug or URL' phrasing but adds no syntax, format, or edge-case details beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get an Avito seller (brand page) by slug or URL'. It also enumerates the returned fields, which distinguishes it clearly from sibling tools like run_avito_items or run_avito_categories. An agent can tell exactly what this tool does without opening the schema.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as run_avito_items_search or run_avito_items. It implies the use case (fetch a seller given a slug or URL) but never states conditions, prerequisites, or exclusions. This is comparable to the calibration example where 'Update shared drive settings...' received a 2.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses the billing cost ('10 point per returned record') and the shape of the returned payload, but says nothing about not-found behavior, whether the lookup is a pure read, 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?

One front-loaded sentence that leads with the verb and resource before enumerating fields and pricing. The field list is long but each item is informative 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?

With no output schema, enumerating the returned fields (name, status, start date, address, legal form, activities, directors, contact details, establishment units) is genuinely necessary and it is present, as is cost. Missing only edge-case behavior such as invalid or unknown enterprise numbers.

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

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

Schema description coverage is 100% and the single 'company' parameter already documents its accepted formats with an example. The description restates the accepted input types but adds no new syntax or normalization guidance, 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 ('Get one company'), the resource, the registry (KBO/BCE), the lookup key (enterprise number or registry URL), and enumerates the returned data fields. The word 'one' implicitly separates it from the sibling run_be_companies_search, but that alternative is never named, so the differentiation is left to inference.

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

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

Usage is implied: call this when you already have an enterprise number or registry URL and want a single company record. There is no explicit statement of when not to use it (e.g. when you only have a company name and should use run_be_companies_search), and no prerequisite or failure guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds a valuable cost signal ('1 point per returned record'), but omits other important behavioral details such as authentication requirements, rate limits, or pagination behavior. This partial coverage merits a middle score.

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

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

The description is two short sentences with zero waste. It front-loads the core search purpose and immediately follows with the cost model, making it easy to scan and understand.

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 absence of an output schema and annotations, the description does a good job of listing the returned fields (name, enterprise number, status, address, link) and including cost information. It omits details like authentication or rate limits, but for a search tool with a fully documented input schema, it is largely complete.

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

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

Schema description coverage is 100%, meaning all four parameters are already well documented in the input schema. The description only echoes that the search is by company name (corresponding to the 'keyword' parameter) and lists output fields, adding no new semantic detail about parameters like status, max_items, or start_page. 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 ('Belgium company registry (KBO/BCE)') and clarifies it operates by company name, listing returned fields. However, it does not explicitly distinguish this tool from its sibling run_be_companies, which likely provides a detail lookup by enterprise number, so it falls short of the top score.

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

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

The description implies usage by stating it searches 'by company name', but offers no explicit guidance on when to use this tool versus alternatives like run_be_companies or other country-specific searches. There are no exclusions or prerequisite conditions mentioned.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a genuinely non-obvious behavioral trait — the cost ('15 point per returned record') — and enumerates the returned data set, though it says nothing about permissions, error behavior, or rate limits.

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

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

The action and scope are front-loaded in the opening clause, and the trailing field list, while long, substitutes for a missing output schema rather than padding. It is a single dense sentence, 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 and no annotations, the description compensates by enumerating the returned fields (name, status, beneficial owners, court case files, etc.) and the cost, which is enough for correct invocation. The main gap is the absence of routing guidance versus the search and filings siblings.

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

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

Schema description coverage is 100% and the schema already documents the sole 'company' parameter with format ('UIC (ЕИК) or registry URL. e.g. 831902088'). The description restates 'by UIC (ЕИК) or registry link' without adding format or validation 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 one company from the Bulgaria registry (Commercial Register)') and pins the scope to a single record, which cleanly separates it from run_bg_companies_search. An agent can tell what it fetches without opening the schema.

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

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

The 'one company' framing and the input format (UIC or registry link) imply you call this when you already hold a specific company identifier, but the description never names run_bg_companies_search or run_bg_company_filings as alternatives or states when to prefer them. Usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a genuinely useful behavioral trait – '1 point per returned record' cost – but says nothing about rate limits, auth, result truncation at 250, or whether results are cached/live.

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

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

Two tight sentences with the core purpose front-loaded and the cost note appended. Dense but no filler; only the field enumeration could be trimmed since the schema/output handling already implies 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, listing the returned fields (name, UIC, legal form, card link) is valuable and covers the return-shape gap. Missing pieces are minor: no routing to run_bg_companies for details and no note on paging behavior.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning: it states keyword accepts a UIC (ЕИК) in addition to a company name, which the schema only documents as 'Company name. e.g. sopharma'. It still adds nothing about max_items or start_page behavior.

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

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

States a specific verb (Search) and resource (Bulgaria company registry / Commercial Register), plus the lookup keys and the fields returned. It is clearly distinguishable from generic search siblings, though it never names run_bg_companies or run_bg_company_filings to distinguish the detail/filings variants.

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

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

Usage is only implied: an agent can infer 'use this to find Bulgarian companies by name or UIC', but there is no explicit when-to-use, when-not-to-use, or pointer to the sibling detail tool for card-level information. The lookup-key note is the only real guidance.

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

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

With no annotations, the description carries the full burden and it does disclose genuinely useful behavior: results are ordered newest-first and the tool costs '1 point per returned record', a billing trait an agent cannot infer from the schema. It omits auth requirements and rate limits, but the ordering and cost disclosure is meaningful added context.

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

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

A single dense sentence that front-loads the purpose followed by return fields and cost. Nothing is wasted, though the run-on packing of five concepts into one sentence is slightly heavy.

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

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

For a tool with no annotations and no output schema, the description covers the essential input modes, the returned field set, result ordering, and per-record cost. It leaves pagination behavior relative to start_page/max_items implicit, but an agent has enough 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 all three parameters are already documented with examples and constraints, making the baseline 3 appropriate. The description restates the identity input (UIC/registry URL) but adds no new syntax or interaction details beyond the schema.

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

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

States a specific verb (List) and resource (announced acts of a Bulgaria company in the Commercial Register), and enumerates the returned fields (announcement date, act type, title, document link). This cleanly distinguishes it from run_bg_companies, which covers company master 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?

Gives the accepted input forms (UIC/ЕИК or registry URL) so the agent knows how to invoke it, but never states when to choose this over siblings like run_bg_companies or when-not to use it. Usage is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the cost model ('Flat 5 points per successful run'), clarifying that billing occurs per run and only on success. However, it omits failure behavior (e.g., unknown CNPJ), auth requirements, and any rate-limit or caching notes.

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 core lookup contract first, the cost note second. No filler, nothing redundant, and the highest-value information (what it fetches and by what key) is front-loaded.

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

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

For a single-record lookup with no output schema, enumerating the returned fields (name, status, registration date, address, legal form) plus the cost gives the agent enough to call it correctly. Minor gaps remain around not-found/error behavior and whether the URL form accepts any registry URL.

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

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

Only one parameter with 100% schema description coverage, so the schema already documents the accepted format and example. The description restates 'registration number or registry URL' without adding syntax, normalization, or fallback guidance beyond the schema, so baseline 3 applies.

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

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

Specific verb ('Get one company') plus precise resource (Brazil registry / CNPJ / Receita Federal) and the exact lookup key (registration number or registry URL). The phrasing 'one company' implicitly distinguishes this single-record lookup from the sibling run_br_companies_search, and the returned fields are enumerated.

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 tells the agent what input is accepted ('by registration number or registry URL'), which implies the usage context, but it never states when to prefer this over run_br_companies_search or what to do when only a name is known. Usage is inferred rather than prescribed.

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

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

With no annotations the description carries the full burden, and it does disclose a meaningful behavioral trait: the per-record credit cost. However it says nothing about rate limits, required auth, pagination behavior, or what happens on a zero-result search, leaving notable gaps for a registry-query tool.

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

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

A single sentence front-loads the resource and data source, then the query dimension and return fields, with the cost note appended. 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?

For a four-parameter registry search with no output schema, the description usefully enumerates the returned fields and cost model, and the schema covers the parameters. But without annotations or an output schema, more should be said about pagination semantics and result limits than is present.

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

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

Schema coverage is 100%, so keyword, status enum, max_items (up to 250, default 25), and start_page are all documented in the schema. The description adds only that keyword is a company name, 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 ('Search the Brazil company registry (CNPJ / Receita Federal data) by company name') and lists the returned fields (name, CNPJ, status, link). It clearly reads as the search variant of the sibling run_br_companies, 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?

There is no when-to-use/when-not guidance and no mention of the non-search sibling run_br_companies or when to prefer a direct lookup over a keyword search. The only usage-relevant signal is the billing note ('1 point per returned record'), which is cost, not routing.

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

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

No annotations exist, so the description carries the full burden. It discloses the returned data fields and, unusually, the cost ('5 point per returned record'), which is real behavioral information an agent needs. It still omits what happens on a miss, identifier validation rules, and any rate/auth constraints.

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 verb, source and lookup key before enumerating fields. The field list is long but each item is informative; only minor trimming is possible.

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

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

With no output schema and no annotations, the description usefully enumerates the returned fields and states the cost, covering both input and output expectations. Missing only error/miss behavior and any constraint on which identifier forms are accepted.

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

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

Schema description coverage is 100% and the single parameter is already documented with an example in the schema. The description restates the accepted identifier forms but adds no format or syntax 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 federal corporation from the Corporations Canada registry), and the accepted identifiers (corporation number or registry link). The word 'one' plus the identifier-based lookup implicitly separates it from run_ca_companies_search, but no sibling is named explicitly.

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

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

The identifier-based input implies a single-record lookup use case, which is reasonable context, but there is no explicit statement of when to prefer this over run_ca_companies_search or run_ca_company_filings, nor any 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?

No annotations exist, so the description carries the full burden. It usefully discloses the cost model ('1 point per returned record'), a genuine behavioral trait, but says nothing about pagination semantics, result caps, rate limits, or auth. It is a read-only search by implication only.

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

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

A single sentence with the core purpose front-loaded, followed by the field list and cost note. The colon-joined field enumeration is slightly dense 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?

With no output schema, the description compensates by listing returned fields (name, corporation number, status, business number, link) and disclosing the cost. It omits pagination and rate-limit behavior for a 4-parameter paged search, which keeps it short of complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning by stating the keyword can match corporation number or business number in addition to name — information the schema's keyword field ('Corporation name') omits. This is a slight tension with the schema but is net value-adding.

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

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

The description names a specific verb (Search) and resource (federal corporations in the Corporations Canada registry) and enumerates the search keys and returned fields, so the agent knows exactly what it does. It does not, however, explicitly differentiate from the sibling run_ca_companies (the non-search counterpart), leaving that distinction to inference.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative is named. The agent must infer from 'Search' that this is the lookup tool versus run_ca_companies, and gets no help choosing between the many country-specific 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the pricing model ('1 point per returned record'), which is real behavioral context beyond the schema, but it does not state that the operation is read-only, how results are paginated, or what format the records take.

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 the resource and scope front-loaded and the cost note appended. No waste, though the phrasing is slightly dense and 'Certificates and filings' could be unpacked.

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 returned fields (date, type, amendment details), and with no annotations it adds a cost disclosure. What remains missing is the read-only nature and pagination behavior, minor gaps for a straightforward lookup tool.

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

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

Schema description coverage is 100%, so all three parameters (company, max_items, start_page) are already documented in the schema. The description's mention of 'date, type and amendment details' describes returned fields rather than adding parameter meaning, 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+resource: certificates and filings of one federal corporation in the Corporations Canada registry, and even lists the data returned (date, type, amendment details). The scope phrase 'one federal corporation' implicitly distinguishes it from the country-level company search siblings, though it never names run_ca_companies or run_ca_companies_search directly.

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

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

Usage is only implied: you would call this for a known corporation to pull its filings. There is no explicit when-to-use, no exclusion, and no pointer to an alternative such as run_ca_companies for general company data, leaving the agent to infer the routing.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavioral fact: a flat 5-point cost per successful run. It does not say whether results are paginated, how large the category set is, or whether any auth is needed.

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, zero waste, and the purpose is front-loaded ahead of the cost note. Excellent signal density for the space it occupies.

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

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

For a zero-param enumeration tool with no output schema and no annotations, the description covers what the tool does, what it returns, and what it costs. Only pagination/result-size behavior is unaddressed, 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The listed output fields are a bonus but relate to return values, not inputs.

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

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

States a specific verb and resource ('List Capterra software categories') and enumerates the returned fields (name, alias, canonical URL). The resource is clearly distinct from sibling run_capterra_category_products, though the description never explicitly contrasts 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: an unparameterized enumeration tool is naturally read as a discovery/seed call before drilling into run_capterra_category_products or run_capterra_products_search. No explicit when-to-use, prerequisites, or alternatives are given.

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

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

With no annotations, the description carries the full burden. It usefully discloses two behavioral traits: results follow Capterra's own ranking and the call costs 1 credit per returned record. It omits return format, read-only confirmation, and whether results are paginated — though max_items in the schema partly addresses volume.

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 core action and scope, followed by ranking and cost notes. No filler, though the '1 point per returned record' clause is a cost detail that could arguably live elsewhere.

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

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

For a simple two-parameter read tool with full schema coverage, the description covers purpose, ordering, and cost. Without annotations or an output schema, it still leaves the expected return fields and pagination behavior unspecified, so it is adequate but not complete.

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

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

Schema description coverage is 100%, so both parameters (category alias/URL and max_items with default/max) are already documented in the schema. The description adds no additional parameter syntax or constraints, making the baseline 3 appropriate.

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

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

States a specific verb (List) and resource (Capterra products) plus a clear scope constraint (within a software category), which distinguishes it from run_capterra_products_search and run_capterra_product. It does not explicitly name those siblings, but the category-scoped listing is unambiguous.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The agent must infer that this is for enumerating all products in a known category rather than searching by keyword (run_capterra_products_search) or fetching one product (run_capterra_product).

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

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

No annotations exist, so the description carries the full burden. It usefully discloses the cost model ('Flat 5 points per successful run'), which is real behavioral context, but says nothing about auth requirements, rate limits, failure/empty-result behavior, or whether a failed run is charged.

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

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

Two compact sentences, front-loaded with the action and resource, followed by the cost note. 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?

For a single-parameter lookup with no output schema, the description compensates by enumerating the returned fields and stating the cost. Only minor gaps remain (error handling, whether reviews/alternatives require other tools), so it is nearly complete.

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

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

Schema description coverage is 100% and the single 'product' parameter is already documented in the schema with the same 'id or URL' wording and an example. The description adds no format, validation, or fallback guidance 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 Capterra product details by id or URL') and enumerates the returned data (vendor, pricing, ratings, features). It implicitly separates itself from run_capterra_products_search by requiring an id/URL, but never names a sibling, 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?

Use is implied by the 'by id or URL' phrasing — an agent can infer it is the direct-lookup counterpart to the search tools — but there is no explicit when-to-use, no prerequisite (e.g. where to obtain a product id), 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses a cost model ('1 point per returned record') but omits auth requirements, rate limits, and pagination behavior. For a read-only retrieval tool 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, well-formed sentence that front-loads the core action and packs input form and returned fields without waste. Nothing extraneous.

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 retrieval tool with a fully documented schema and no output schema, the description covers purpose, input, returned fields, and cost. Missing only pagination/limit behavior, which is a minor 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 both parameters are already documented in the schema. The description echoes 'by id or URL' for the product param but adds no syntax or format detail beyond the schema, and does not mention max_items. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (get) and resource (user reviews for a Capterra product), and specifies the input form (id or URL) plus the returned fields (rating, pros/cons, author). This clearly distinguishes it from siblings like run_capterra_product and run_capterra_products_search without opening their schemas.

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

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

The description implies when to use it (to obtain reviews for a product) but gives no explicit when/when-not guidance or named alternative among the many sibling review/product tools. The 'by id or URL' note hints at routing but stops short of stating prerequisites or 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?

With no annotations, the description carries the full burden. It does disclose billing behavior ('1 point per returned record'), which is valuable cost context absent from the schema. However, it says nothing about read-only semantics, pagination, rate limits, or partial-result 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?

Two short sentences, front-loaded with the action and resource; the second sentence adds the billing note without waste. No redundancy 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?

It partially covers return content (name, rating, review count, image), which matters since there is no output schema, and flags the point cost. But for a search tool with several close siblings, the lack of routing guidance and any pagination/auth note leaves gaps.

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

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

Schema coverage is 100% with only two simple parameters (query, max_items), so the schema already documents both fully. The description adds no syntax, format, or matching hints beyond the schema's own example.

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

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

States a specific verb (search) and resource (Capterra software products) and clarifies it is keyword-based, plus what fields come back. It does not differentiate from the close sibling run_capterra_category_products, which is a category-driven variant of the same resource.

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 keyword' implies you need a text query, but there is no explicit when-to-use guidance, no statement of when to prefer run_capterra_category_products or run_capterra_product instead, and no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a behavioral trait beyond structured data — the flat 5-point cost per successful run — and enumerates the returned attributes. However, it says nothing about authentication, failure/error behavior, or rate limits.

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

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

A single compact sentence plus a short cost note; the scope and identifier are front-loaded. The cost sentence is useful but appended rather than integrated, keeping it just short of ideal.

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

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

With no annotations and no output schema, the description compensates by enumerating the returned fields (name, status, registration date, address, legal form, economic activity, legal representation, establishments) and stating run cost. That covers what an agent needs to call it correctly, though failure modes remain unaddressed.

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

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

Single parameter with 100% schema description coverage; the schema already documents 'NIT or registry URL. e.g. 899999068-1'. The description restates the same identifier semantics without adding format rules, validation, or edge-case behavior, 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 names a specific verb+resource ('Get one company from the Colombia registry (RUES, Registro Mercantil)') and pins the input to a NIT or registry URL. Sibling run_co_companies_search is not named, but 'one company ... by NIT or registry URL' vs. a search tool is reasonably inferable. It stops short of explicit 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?

The 'one company ... by NIT or registry URL' phrasing implies usage (you already have an identifier, so you don't need search), but there is no explicit when-to-use statement, no 'when not to use', and no named alternative like run_co_companies_search.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the billing model ('1 point per returned record'), which is real cost context an agent needs, but says nothing about pagination behavior, result limits, or how start_page/max_items interact.

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

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

A single front-loaded sentence with the registry, search key, returned fields, and cost packed in; nothing is redundant. Slightly dense but 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 and no annotations, the description partially compensates by enumerating the returned fields and the per-record cost. However it omits pagination semantics and any guidance about result scope, leaving gaps for a 4-parameter 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 already documents keyword, status, max_items, and start_page, making the baseline 3 appropriate. The field list in the description (name, NIT, chamber of commerce, category, link) describes returned data rather than input parameters, so it adds little parameter meaning beyond the schema.

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

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

States a specific verb (Search) and a precise resource (the Colombia company registry, named as RUES/Registro Mercantil), and adds the search key (by name). An agent can distinguish it from generic search, though it never names the sibling run_co_companies that would be the lookup counterpart.

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 name' implies the usage context (find companies from a name keyword), but there is no explicit when-to-use guidance, no exclusions, and no routing to or from the sibling run_co_companies tool.

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

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

With no annotations provided, the description carries the full burden, and it does disclose two useful traits: the approximate scale (~700 sites) and the cost model ('Flat 5 points per successful run'). It omits auth requirements, whether the call is read-only (implied but unstated), and how the country filter affects 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, front-loaded with what the resource is and immediately following with the cost, so nothing is buried. The long comma-separated field list is dense but 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?

For a no-annotation, no-output-schema lookup tool, the description effectively substitutes for the missing output schema by enumerating returned fields and discloses the cost model. A brief note on how the optional country filter behaves would make it fully complete.

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

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

The single optional country parameter is fully documented in the schema (100% coverage), so the baseline is 3. The description mentions 'country' only as a returned field, not as a filter, so it adds no semantics beyond the schema.

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

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

The description states a specific resource (a directory of ~700 Craigslist regional sites) and enumerates exactly what it returns, which clearly separates it from siblings like run_craigslist_postings or run_craigslist_categories. It does not, however, use an explicit verb or directly state the tool's role as a lookup source for search area values.

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

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

The parenthetical 'the area value for searches' hints that this tool supplies inputs to the postings/search tools, but there is no explicit when-to-use or when-not-to-use guidance and no sibling is named as an 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses the cost model ('Flat 5 points per successful run'), which is genuinely useful, but never states that this is a safe read-only lookup, whether any auth/quota applies, or that the section filter just narrows the list. Partial coverage for an unannotated tool.

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

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

Two compact sentences with the identity of the tool front-loaded and the fields listed up front. The cost sentence is short and earns its place, though it is a slightly separate concern.

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 reference-lookup tool with one optional enum param and no output schema, the description names the returned fields (category, alias, description, section), which is the main thing an agent needs. It is nearly complete, missing only explicit read-only/behavioral framing.

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 'section' param is fully documented with an enum and human-readable labels in the schema. The description adds 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 resource (Craigslist posting categories) and enumerates the returned fields (alias, description, section), so the agent knows exactly what it gets. It does not explicitly distinguish itself from siblings like run_craigslist_areas, but the resource is unambiguous.

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

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

Usage is only implied: calling it 'the category value for searches' hints it is a reference lookup feeding search tools, but there is no explicit when-to-use, no exclusions, and no named alternative. Adequate but leaves the agent to infer the workflow.

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

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

No annotations are provided, so the description carries the behavioral burden. It does disclose the cost model ('Flat 5 points per successful run') and enumerates the returned payload, but omits auth needs, rate limits, and failure 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?

One front-loaded sentence that leads with the operation and then lists payload contents; no filler. The long field enumeration is dense but each item conveys distinct returned data, especially valuable without 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?

With no output schema and no annotations, the description compensates by enumerating the returned fields (title, price, body, VIN, images, dates) and the cost. It is adequate for the tool's low complexity, though error and edge-case behavior remain 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% and the single parameter is fully documented in-schema with the 22-character format and an example. The description's 'by id or URL' merely restates that, adding no syntax or constraints 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: fetch a full Craigslist posting by id or URL. The 'Full ... posting by id or URL' phrasing implicitly separates it from run_craigslist_postings_search and run_craigslist_postings_seller, but it never names those alternatives, leaving the differentiation 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 implied by the requirement of an id or URL, signaling a single-item lookup rather than a search. There is no explicit when-to-use vs when-not-to-use guidance and no mention of the sibling search/seller 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?

With no annotations, the description carries the full burden and does useful work: it discloses the per-record cost ('1 point per returned record') and enumerates the returned fields, compensating for the absent output schema. It stops short of describing pagination limits beyond what max_items/start_page imply.

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 and scope, then compactly groups the 60+ filters into a single readable list before noting the cost. No filler, and it fits a very large schema in two sentences.

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

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

For a 67-parameter tool with no annotations and no output schema, the description covers purpose, filter breadth, return fields, and cost. The one notable gap is guidance on choosing the required 'area' value (a sibling like run_craigslist_areas exists for that) and pagination behavior.

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

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

Schema description coverage is 100%, so every one of the 67 parameters is documented in the schema itself. The description's summary of filter groups (vehicle, motorcycle, boat, housing, job, gig, event) adds little beyond what the schema already names, 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 (live Craigslist postings) with scope (any regional site) and the filter categories covered. It clearly reads as the search tool among the Craigslist siblings, though it never explicitly names run_craigslist_postings or run_craigslist_postings_seller to disambiguate.

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 phrasing implies usage (search live postings, in any regional site) but gives no explicit when-to-use vs. the retrieval-by-ID sibling, no prerequisites, and no exclusions. Usage is inferable rather than stated.

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

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

No annotations are present, so the description carries the burden. It usefully discloses the cost model ('1 point per returned record') and that the result is the seller's full inventory, but it says nothing about pagination behavior, permissions, or upstream rate limits despite exposing max_items and start_page parameters.

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 scope is front-loaded and the cost note follows immediately. 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?

With no output schema and no annotations, the description conveys what the tool returns (the seller's postings) and the billing implication, which covers the essentials. However, for a 5-parameter, paginated listing tool it omits any mention of paging through the full inventory or result shape, leaving gaps that structured fields do not fill.

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 documented enum for sort and defaults for max_items/start_page, so the schema does the heavy lifting. The description adds no format or interpretation detail beyond what the schema already states, making the baseline 3 appropriate.

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

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

The description names a specific resource and scope: all postings published by the seller of a given Craigslist posting, with concrete examples of what a seller is (dealer, landlord, shop). It implicitly distinguishes itself from siblings like run_craigslist_postings and run_craigslist_postings_search by anchoring on the seller, but it never names those alternatives 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 only implied: the phrase 'of a given Craigslist posting' signals that an existing posting ID/URL must be supplied first, which matches the single required parameter. There is no explicit when-to-use versus when-not, and no sibling is named as an alternative for a different 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?

There are no annotations and no output schema, so the description carries the transparency burden. It does disclose the read-only nature and the specific data fields returned, but it does not mention behavior for invalid URLs, missing fields, rate limits, or error cases.

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 a parenthetical field list. Every part earns its place, and there is no redundant wording.

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

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

For a one-parameter lookup tool, the description is largely sufficient: the input is fully documented by the schema, and the description clarifies the expected output fields. It is missing explicit usage guidance and failure behavior, but the low complexity keeps these gaps minor.

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 url parameter with an example. The description merely restates 'Crunchbase company URL' without adding deeper parameter semantics, so it meets the baseline but adds little beyond the schema.

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

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

The description uses a specific verb ('Fetches') and names a clear resource: structured company data from a Crunchbase company URL. The enumerated fields (website, location, funding, etc.) make the tool's scope concrete and distinguish it from sibling LinkedIn/email/phone tools.

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

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

The use case is implied: use this when you have a Crunchbase company URL and want company data. However, the description does not explicitly state when to prefer this tool over siblings like run_linkedin_company_search, nor does it provide exclusions or alternative routing.

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

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

With no annotations, the description carries the full burden. It adds useful behavioral context: the cost ('10 point per returned record') and a detailed list of returned fields. But it omits prerequisites such as authentication requirements, rate limits, or error behavior, so it is only partially transparent.

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

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

The description is a single, front-loaded sentence that packs purpose, input formats, return fields, and cost without filler. It is dense but every clause adds value, though the long list of return fields could be slightly more structured.

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 lookup with no output schema, the description compensates by enumerating the returned fields (name, status, registration date, etc.) and disclosing the cost. It covers what an agent needs to invoke the tool, though it could mention any authentication or error-handling expectations.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by listing the specific registration number prefixes accepted (HE, EE, AE, S, BN) and explicitly allowing a registry link, which helps the agent format the input correctly.

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

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

States a specific verb ('Get one organisation') and resource ('from the Cyprus registry (Registrar of Companies, DRCOR)'), and specifies the lookup keys (registration number or registry link). Distinguishes itself from the sibling search tool by scope ('one organisation').

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

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

The description makes clear this is for retrieving a single entity by exact identifier or link, which implies when to use it versus a search. However, it does not explicitly name the alternative (run_cy_companies_search) or state exclusions, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden, and it does add one genuinely useful behavioral fact: the cost model ('1 point per returned record') plus the fields returned. It omits permissions/auth needs, rate limits, and pagination behavior, so it is only partially transparent.

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

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

A single front-loaded sentence covering scope, source, returned fields, and cost, with no redundant or filler text. 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 4-parameter, no-output-schema search tool, the description compensates by enumerating what a record contains. The only shortfall is absence of pagination/limit guidance despite max_items and start_page existing.

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 keyword, status, max_items and start_page are already documented with examples and enum meanings. The description adds nothing about parameter syntax or defaults, 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?

Names a specific verb (Search) and resource (Cyprus company registry / Registrar of Companies, DRCOR), and scopes it to name-based lookup, listing the returned fields. It clearly differs from the sibling run_cy_companies (single-company detail) and other country searches, though it never explicitly says so.

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 'search ... by name' implies the tool's role versus the per-company detail sibling, but there is no explicit when-to-use/when-not statement or named alternative. Usage is inferred rather than stated.

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

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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses the cost model ('1 point per returned record') and the returned fields (form, date, page number), but says nothing about permissions, rate limits, or pagination behavior beyond the implicit 'List' read semantics.

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 is front-loaded with the core action and resource before the category enumeration and cost note. Slightly packed but every clause contributes; 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?

For a read-only listing tool with no output schema and fully documented parameters, the description covers purpose, accepted identifiers, category scope, and cost. Return values needn't be explained absent an output schema, so it is largely complete.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including the enum options for 'list'. The description restates those same categories rather than adding 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?

Specific verb (List) plus precise resource (the filings of one Cyprus organisation) and an enumeration of the filing categories (documents, charges, translations, HE32, pending). The scope word 'filings' cleanly separates it from the sibling run_cy_companies and run_cy_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?

Usage is implied: you call it to retrieve filings for a known company, keyed by registration number or registry link. However, it never states when to prefer this over run_cy_companies or run_cy_companies_search, nor any prerequisites or exclusions. Adequate but leaves routing to inference.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses pricing ('5 point per returned record') and enumerates the returned data, but says nothing about authentication, rate limits, or error behavior for an invalid IČO/URL.

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

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

Three sentences, front-loaded with the identifier format before the returned-fields list and the cost note. The field enumeration is somewhat long but every item is informative, 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 must describe return values, and it does list them (name, status, registration date, address, court file number, legal form, business scope, share capital, officers, shareholders, branches) plus cost. Only error/edge-case behavior 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 single parameter is already fully documented in the schema (IČO or registry URL, example 45274649). The description restates the same information with the added detail that IČO is 8 digits, which is mildly useful but mostly redundant at 100% schema coverage.

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

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

States a specific verb and resource ('Get one company from the Czech Republic commercial register (Justice.cz)') and names the exact lookup keys (IČO 8 digits or registry URL). This clearly distinguishes it from the sibling run_cz_companies_search, which would be name-based 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 description tells the agent what input is required (a registration number or registry URL), which implicitly tells it when this tool applies versus a search. However, it never explicitly names run_cz_companies_search or states when NOT to use this tool, so the routing is inferred 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the pricing model ('1 point per returned record') and the returned fields, which is real added value, but says nothing about pagination behavior, rate limits, or authentication, leaving meaningful gaps for a search tool.

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

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

Two compact sentences, front-loaded with the action and data source, followed by the returned fields and cost. No filler; only the missing sibling routing keeps it from a 5.

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

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

There is no output schema, so the description's listing of returned fields (name, IČO, status, address, link) is valuable and largely compensates. Parameter coverage is complete via the schema; only pagination guidance is absent, which is a minor gap for a search tool.

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

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

Schema description coverage is 100%, so keyword, status, max_items, and start_page are already fully documented in the schema. The description only restates the name query ('by company name') and adds no syntax or format detail 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 verb (Search), the exact resource (Czech Republic commercial register / Justice.cz), the query field (company name), and the returned fields. It clearly identifies what it does, but does not distinguish itself from the sibling run_cz_companies or run_cz_company_filings, 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 phrase 'by company name' implies the intended input and use case, but there is no explicit when-to-use guidance, no when-not, and no reference to the alternatives (run_cz_companies, run_cz_company_filings) that share this namespace. Usage is only inferable.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful behavioral traits: results are ordered newest first, the specific fields returned, and a per-record credit cost ('1 point per returned record'). It omits any mention of read-only safety, rate limits, or pagination semantics beyond what the schema states.

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 before the identifier format and returned fields. It is well organized with no filler, though the run-on structure packs return-field enumeration and cost into the same 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?

There is no output schema, and the description compensates by enumerating the returned fields (document number, type, description, period, filing dates, pages, link) plus ordering and cost. Combined with full schema coverage on inputs, an agent has nearly everything needed, though permissions/pagination behavior is 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 all three parameters (company, max_items, start_page) are already documented in the schema. The description restates the 'IČO or registry URL' input format but adds no new syntax, format, or pagination detail beyond the schema; baseline 3 applies.

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

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

States a specific verb (List) and resource (documents filed in the Czech Republic Collection of Documents) with the exact source registry (Justice.cz) and the identifier type accepted. It is clearly distinguishable from siblings like run_cz_companies (company data) and other-country filings tools.

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

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

The description implies the use case (retrieve filings for one company) and names the accepted inputs, but gives no explicit when-to-use vs. when-not guidance and never contrasts with run_cz_companies or run_cz_companies_search, which an agent could plausibly confuse it with.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose non-schema behavior ('Flat 5 points per successful run', a cost/credits hint) and the shape of the result, but says nothing about authentication requirements, what happens on an unknown registration number, or whether a failed lookup still costs points.

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

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

One sentence, front-loaded with the verb and resource, followed by the identifier options and returned fields. No filler or redundant restatement of the 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 parameter, no annotations, and no output schema, the description usefully compensates by naming the fields returned and the pricing model. It is nearly complete, though a note on failure/not-found behavior 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% for the single 'company' parameter, which already documents that it accepts a registration number or registry URL and gives the example 24256790. The description restates the same accepted inputs without adding format constraints, 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 Denmark registry (CVR)'), names the accepted identifier types, and enumerates the returned fields (name, status, registration date, address, legal form). 'one company' plus the identifier-based lookup implicitly and clearly separates it from the batch-oriented sibling run_dk_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?

The description tells the agent how to invoke it (registration number or registry URL) but never states when to pick this over run_dk_companies_search or run_dk_company_filings. The single-record vs. search distinction is only implied by the word 'one'.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses a cost trait ('1 point per returned record'), which is valuable beyond structured fields, but says nothing about rate limits, auth, or pagination behavior beyond what the schema's page/size params imply.

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

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

A single tight sentence plus a cost note. The core purpose is front-loaded and nothing is wasted, though the returned-field list and cost clause are packed into one long 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?

There is no output schema, so it is genuinely helpful that the description enumerates the returned fields (name, registration number, status, address, link). Combined with disclosed cost and a fully covered schema, an agent has enough to invoke it correctly, though sibling routing 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 description coverage is 100%, so the schema already documents keyword, status, max_items, and start_page fully. The description adds no parameter-level detail (e.g., wildcard or exact-match name behavior); baseline 3 applies.

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

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

States a specific verb (search), resource (Denmark company registry / CVR), and the query dimension (by company name), plus the returned fields. It does not explicitly differentiate from the sibling run_dk_companies, so an agent must infer the distinction between lookup and 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 implied: search Danish companies by name. There is no explicit when-to-use/when-not guidance, and the obvious alternative (run_dk_companies for a direct identifier lookup) is never named, nor is run_dk_company_filings mentioned.

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

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

With no annotations, the description carries the full burden. It usefully discloses the credit cost model ('1 point per returned record') and the shape of returned records, but says nothing about pagination behavior, whether results are capped, authentication requirements, or record freshness - gaps that matter for a scraping-backed filings 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 tight sentences that front-load the resource and scope before the field list and cost note. No filler, though the returned-field enumeration could arguably be inferred from the response payload.

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

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

There is no output schema, so the description should reasonably explain the return surface; it lists record fields but omits pagination semantics (start_page/max_items interaction), possible empty results, and rate/credit behavior beyond the per-record note. Adequate but with clear gaps for a 3-parameter, no-annotation 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%: company (registration number or URL, with example), max_items (max 250, default 25) and start_page are all documented in the schema. The description adds no parameter-level meaning beyond that, 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 (annual reports, announcements, registrations of one Danish company) keyed by CVR, and enumerates the returned fields (date, type, description, document links). This distinguishes it from run_dk_companies/run_dk_companies_search, which cover company registry data rather than filings, though the sibling distinction is implicit rather than stated.

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

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

There is no when-to-use guidance, no prerequisites (e.g. that a CVR is required), and no routing to or from alternatives such as run_dk_companies or run_se_company_filings. The '1 point per returned record' note is a cost signal, not usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It does add genuinely useful cost context ('Flat 5 points per successful run'), but it never states that this is a read-only operation nor describes the shape or size of the returned tree. Cost disclosure is valuable; the safety/return profile is missing.

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 waste; the resource and its scope are front-loaded ahead of the cost note. Nothing is padded.

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

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

For a trivial no-parameter, no-output-schema tool, the description covers what it returns at a high level and discloses the credit cost. Only the return structure (depth, IDs, localization) is left unstated, which is a minor 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?

The tool takes zero parameters, and the schema is an empty object, so there is nothing for the description to disambiguate. Baseline 4 applies for a no-param tool.

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

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

States a specific verb (Get) and resource (eBay browse category tree) with explicit scope: every department, category, and subcategory. This is clearly distinguishable from siblings like run_ebay_item_search or run_ebay_product, which operate on items rather than the taxonomy.

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

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

No when-to-use or when-not-to-use guidance is given, nor any mention of alternatives or prerequisites. An agent must infer that this is the taxonomy lookup used to resolve category IDs before calling search/item 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the cost model ('Flat 5 points per successful run'), which is real added context, but omits permission/auth requirements, error or empty-result behavior, and whether the call is read-only (only implied by 'Get').

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

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

Two short sentences, front-loaded with the verb and resource, followed immediately by the returned fields and cost. No filler; 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-parameter read tool with no output schema, listing the returned fields and the point cost makes it essentially callable. The gap is the lack of differentiation from sibling eBay tools, but nothing critical to invocation is missing.

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

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

Schema description coverage is 100% and the single 'item' parameter is documented as 'Item ID or URL. e.g. 336776720041'. The description's 'by item ID' adds nothing 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 full eBay listing details by item ID') and enumerates the returned fields (title, price, condition, images, seller). However, it does not distinguish itself from the sibling run_ebay_product, which an agent could easily confuse with this tool.

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

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

The phrase 'by item ID' implies the lookup mode, but the description offers no explicit when-to-use guidance and never names alternatives such as run_ebay_item_search (to find an ID) or run_ebay_product. An agent must infer the routing 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?

With no annotations, the description carries the full burden. It usefully discloses two behavioral facts: results are limited to *active* listings (not sold/closed), and each returned record costs 1 point. However, it omits pagination behavior (there is a start_page param), rate limits, and any auth/result-format detail.

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 waste; the core action is front-loaded and the point-cost caveat follows immediately. Nothing 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?

For a 9-parameter search tool with no annotations and no output schema, the description partially compensates by naming returned fields and the point cost, but it leaves pagination (start_page/max_items interaction) and result-set behavior unexplained. Adequate but incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters, including enum options and defaults. The description names keyword and condition as concepts but adds no syntax, format, or defaulting information beyond what the schema provides — the baseline 3 applies.

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

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

States a specific verb+resource (search active eBay listings) plus keyword scope and the fields returned (title, price, condition, seller summary). It is distinguishable from run_ebay_item semantically, but it never names or contrasts the adjacent eBay siblings (run_ebay_seller_items, run_ebay_item), 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?

The description says nothing about when to use this search versus run_ebay_item, run_ebay_product, run_ebay_seller_items, or the search tools of other marketplaces. No prerequisites, no exclusions, no alternative routing is offered.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the response payload (brand, model, rating, price range, specs) and the cost model ('Flat 5 points per successful run'), but says nothing about permissions, rate limits, failure behavior, or what happens with an invalid ePID.

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 the lookup key and payload front-loaded and the cost note appended. Nothing is wasted, though it is minimal rather than exemplary.

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 correctly compensates by listing the returned fields, and it adds the point-cost disclosure. It is nearly sufficient for a one-parameter lookup, with only error/auth behavior left unstated.

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

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

Schema description coverage is 100% and the single parameter is already documented as 'ePID or URL. e.g. 1234567890'. The description reinforces that the lookup is by ePID but adds no format or validation 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.