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

There are no annotations, so the description carries the responsibility for behavioral disclosure. It does disclose that amounts are returned as raw strings exactly as published and usually in PLN, which is useful. It does not mention failure behavior, empty results, or whether the extraction can be partial, leaving some behavioral uncertainty.

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

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

The description is compact: one purpose sentence, one detail sentence, and one example. It is front-loaded with the primary action and contains no filler, making it easy for an agent to parse quickly.

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 tool with an output schema, the description covers input, extraction scope, return format, and a concrete example. It omits explicit comparison with sibling tools, but that is more of a usage-guidance issue; the core information needed to invoke the tool correctly 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?

The schema has 0% description coverage for tender_id, so the description must compensate. The example call demonstrates the expected ID format and connects the parameter to a tender notice, but the description never explicitly defines tender_id or explains where such an ID comes from. This is helpful but not fully sufficient.

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: extract contract/order money amounts from a tender notice full text. It also lists the exact kinds of values found (contract value, total paid, estimated value, etc.) and notes that these are not exposed by structured API fields, which distinguishes it from sibling lookup 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 usage when structured API fields do not expose certain monetary amounts, giving the agent a decision rule. However, it does not explicitly name sibling alternatives or state when not to use this tool, so the guidance remains mostly implicit.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Get' implies a read operation, and the optional contractors behavior is disclosed. However, it does not mention NIP validation, error/not-found behavior, or that include_winning_contractors could trigger heavier computation.

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 short, front-loaded with the core purpose, and both examples earn their place by demonstrating parameter usage. There is no redundant or boilerplate 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?

For a simple read-only lookup with two parameters and an output schema, the description covers the main inputs and optional behavior. It could add a note on when to use get_contractor instead, but nothing critical is missing for basic invocation.

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

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

Schema description coverage is 0%, but the description compensates by explaining that nip identifies the procuring entity and that include_winning_contractors controls whether top winning contractors are returned. The two examples show realistic call forms and how to set the boolean, though NIP format and default behavior are left to the schema.

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

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

The description uses a specific verb and resource: it retrieves a procuring entity (zamawiający) profile by NIP, with an optional enrichment of frequently winning contractors. This clearly distinguishes it from sibling tools like get_contractor and search_entities.

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

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

It provides clear context: use this when you have a buyer's NIP and want a buyer profile, optionally with top winning contractors. It does not explicitly name alternatives or exclusion conditions, which prevents 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 provided, the description carries the transparency burden and does disclose a non-obvious upstream behavior: the API sometimes ignores the requested window, so the response must be verified against the actual days applied. This is valuable beyond the schema, though it does not discuss permissions 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?

The description has three compact components: purpose, one critical caveat, and two examples. Every sentence earns its place, and the most important behavioral warning is prominently placed before the examples.

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 stats tool with an output schema, the description provides the computed metrics, input examples, and a necessary caveat about response verification. It does not discuss routing to sibling tools, but that omission is already reflected in usage_guidelines.

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

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

Schema description coverage is 0%, so the description must compensate. It does so with concrete examples ('302', '45240000-1', window='quarter') and identifies cpv as a CPV category. The window parameter's allowed values are left to the schema enum, but the examples and 'requested window' phrasing convey its role clearly.

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

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

The description opens with 'Get aggregate statistics for a CPV category' and enumerates exact metrics: tender count, average and median value, average offers count, average deadline length. This is specific and distinguishes it from siblings like get_province_stats and search_tenders.

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 clearly scopes usage to CPV-category aggregate statistics, and the examples show realistic calls. It does not explicitly state when to prefer a sibling like get_province_stats or when not to use this tool, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does indicate what data is returned, but it does not explicitly state that this is a read-only operation, how missing NIPs are handled, or the effective default for include_winning_buyers. The 'Get' phrasing implies safety, but more explicit behavioral context would be better.

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, information-dense sentences plus a useful invocation example. Every part earns its place, and the core behavior 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 simple two-parameter lookup with an output schema present, the description is largely complete. It could be more complete by noting when to choose this over search_entities/get_buyer and clarifying the ambiguous 'win geography' phrase, but the essential calling context 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?

The input schema has 0% description coverage, so the description must explain the parameters. It does: 'nip' is clearly the contractor identifier, and include_winning_buyers is tied to optionally returning the buyers the contractor most frequently wins tenders from. It does not describe NIP format or the default-true behavior, but the schema default partially covers the latter.

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 action ('Get') and a specific resource ('contractor profile by NIP'), and names the distinctive outputs: win geography and optionally the most frequent winning buyers. This clearly distinguishes the tool from siblings such as get_buyer or search_tenders.

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

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

The context is clear: use this to fetch a contractor profile when you have a NIP. However, it does not explicitly say when to prefer this over alternatives like search_entities or get_buyer, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explains the three output modes and what kind of data is returned, which is useful. However, it does not specify behavior when both province and city are provided, whether arguments are mutually exclusive, or what defaults apply beyond the example-driven use 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?

The description is compact and well-structured: one main sentence defining the tool's capabilities, followed by three minimal example invocations. Every line adds value, and the format is easy to scan.

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

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

For a low-complexity tool with only two optional parameters and an output schema, the description covers the core call patterns and expected responses well. The main gaps are edge-case behavior around combining arguments and possible constraints on city/province values, but the essentials are 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?

The input schema has no descriptions, so the description compensates with concrete examples: province="PL12" and city="Kraków". It clarifies that province expects a code and city expects a name, and ties each parameter to a specific drill-down behavior. The province enum in the schema already provides valid values, and the description reinforces their usage.

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

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

The description clearly states the tool returns tender statistics and specifies three distinct modes: full province ranking, a single province, and city drill-down. It also names the output components (ranking, top buyers, top CPV categories), which distinguishes it from sibling tools like search_tenders and get_category_stats.

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 provides concrete usage guidance through examples: no arguments for the full ranking, a province code for one province, and a city name for drill-down. It does not explicitly contrast with sibling tools or state when not to use it, but the examples give an agent enough context to select it appropriately.

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 disclosure burden. It explicitly warns that full=True can return a very large htmlBody, and that the default response excludes it. This is valuable behavioral context beyond the schema, though it does not mention error behavior or permissions.

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

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

The description is compact and well-structured: summary, parameter behavior, then examples. Every sentence adds necessary information, and the most important scoping detail (by ID) 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 two-parameter read tool with an output schema, the description covers the essential invocation semantics, parameter behavior, and size trade-offs. The output schema handles return-value documentation, so nothing critical is missing for an agent to call it correctly.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining tender_id through concrete examples and clearly documenting the full parameter's effect and default. The agent can correctly invoke the tool with either parameter combination.

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 ('Get') and resource ('full details of a tender by ID'), and gives two concrete ID formats. This clearly distinguishes it from siblings like search_tenders or get_tender_timeline, as it targets a single tender lookup by identifier.

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 the usage context obvious: call this when you already have a tender ID and need full details, reinforced by examples showing both required and optional parameters. It does not explicitly name alternatives or exclusion criteria, but the by-ID framing is strong enough 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 behavioral burden. It discloses that statistics are extracted from result notice text and warns that it works best on specific ID types, implying dependence on notice type. It does not describe error or empty-result behavior, but for a simple read-style extraction tool this is a reasonable level of transparency.

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

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

The description is compact: every sentence carries useful information, the main purpose is front-loaded, and the example is illustrative rather than redundant. There is no filler or repetition of schema fields.

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 tool with an output schema and no nested objects, the description covers the essential context: what the tool does, what kind of ID it expects, how to find that ID, and a working example. Missing failure-mode details are minor given the low complexity and the presence of an output schema.

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

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

Schema coverage is 0%, but the description compensates with a concrete example ID format ('2023/BZP 00559582') and directs the caller to obtain the correct result-notice ID via get_tender_timeline. This adds practical meaning to the bare tender_id parameter, though it stops short of an explicit formal parameter definition.

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?

Description names the operation ('Get offer statistics for a tender'), specifies the exact resource, enumerates the data returned (number of offers, lowest/highest/winning prices), and identifies the extraction source (SEKCJA V). It also distinguishes itself from generic tender retrieval by referencing result notice IDs and the get_tender_timeline workflow.

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

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

The description gives clear usage context: it works best on TenderResultNotice / can-standard / ContractPerformingNotice IDs and instructs the agent to use get_tender_timeline first to find the result notice. It does not explicitly state when not to use it or name alternatives, but the guidance is sufficient for correct selection.

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

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

With no annotations, the description carries the burden. It discloses the output scope (notice chain, dates, notice types) and provides an example, but it does not disclose error behavior, ordering, or any side effects; as a 'get' tool this is a moderate gap.

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

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

Two concise sentences plus a usage example. The information is front-loaded and every part 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?

Given a single required parameter, an output schema, and a read-oriented purpose, the description provides enough to call the tool correctly. It lacks only explicit alternative routing, which is already penalized in usage_guidelines.

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

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

Schema coverage is 0%, so the description must explain the parameter. It does so only implicitly: the example shows '2023/BZP 00510245' and the description ties the parameter to a procurement procedure. This is useful but leaves the identifier format and meaning partly inferred.

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 ('Get') and defines the resource as 'full notice chain... with dates and notice types', enumerating stages. This makes the tool's purpose clear, though it does not explicitly contrast with siblings like get_tender.

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 when the full timeline of a procedure is needed, and the example shows a valid call. However it does not state when to prefer this over get_tender or raw_request, so the selection guidance is only implicit.

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

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

With no annotations to carry the burden, the description does disclose the core behavior: it performs a GET request and requires the path to start with /api/. However, it does not describe response shape, error behavior, authentication expectations, or how params_json is handled behind the scenes, leaving some behavioral ambiguity in an otherwise generic escape-hatch tool.

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

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

The description is compact, front-loaded with the essential 'escape hatch' concept, and every part contributes value. The two examples are practical and demonstrate both parameters without unnecessary prose.

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

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

Given that this is a generic raw API request tool, the description is largely complete: it defines the path constraint, the HTTP method, and when to use it, with examples covering both optional and required parameter usage. It relies on the external API's own endpoint conventions for response details, which is acceptable for an escape hatch, though a note about the response format would make it fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It gives meaningful semantics for path by requiring the /api/ prefix and provides an example showing params_json as a JSON string used for query parameters. However, the description never explicitly explains that params_json is a JSON-encoded query parameter object, how it is serialized, or that it is optional beyond the schema default.

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

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

The description clearly identifies this as an escape hatch for GET requests to any Atlas Przetargów API endpoint, with the explicit path requirement that it must start with /api/. It distinguishes itself from dedicated tooling by stating it is for endpoints not covered by dedicated tools, and the examples reinforce the intended resource and call style.

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 explicitly states when to use this tool: for endpoints not covered by dedicated tools. This directly signals that if a specialized sibling tool exists, it should be preferred, giving the agent a clear routing rule. It also constrains the HTTP method to GET, which is an important usage boundary.

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 must carry the behavioral burden. 'Look up' conveys a read-only, non-destructive operation, and 'by Polish keyword' adds useful input-language context. But it does not disclose matching behavior (e.g., partial/fuzzy matching), result ordering, or error conditions; the output schema mitigates return-format ambiguity somewhat.

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 short, front-loaded with the core purpose, and uses two concrete examples to clarify parameter usage. Every line earns its place, and there is no redundant elaboration.

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 lookup tool with an output schema, the description covers the essential context: what is searched, in what language, and how the optional parameter is used. It does not mention when to prefer this over get_category_stats or raw_request, but the low complexity keeps the remaining gap 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?

The schema provides only bare types and a default, with 0% description coverage. The description compensates well by showing that 'query' is a Polish keyword and demonstrating 'limit' with a concrete example (limit=5), which clarifies that limit controls result size despite the schema not explaining it.

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

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

The description names a specific verb ('Look up'), a clear resource ('CPV (procurement category) codes'), and the required search dimension ('by Polish keyword'). It is clearly distinct from sibling tools like search_tenders and search_entities, which search different object types.

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 suggested usage is implied through the examples showing Polish keywords and an optional limit, so an agent can infer when to call this tool. However, there is no explicit statement of when to use this versus the sibling tools, nor any exclusion such as 'for tender search use search_tenders instead'.

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 disclosure burden. It communicates the core behavior (name-based search returning NIP) and the entity_type filter, but does not disclose matching semantics, result limits, or edge-case behavior; the output schema mitigates return-value ambiguity but not behavioral 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?

The description is compact: one purpose sentence plus two concrete examples. Every sentence pulls weight, and the examples are immediately actionable for an agent deciding how to call the tool.

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

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

For a moderately simple search tool with an output schema, the description is nearly complete: it provides the primary use case, downstream consumers, and representative calls. The main missing piece is limit/result-count behavior, but the default and schema mitigate the gap.

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

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

Schema description coverage is 0%, so the description needs to compensate for the parameters. It clarifies query by saying 'by name' and illustrates entity_type through examples, but it does not explain the limit parameter or its default, and the enum values are only minimally contextualized.

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?

Description states a specific verb and resource: search buyers (zamawiający) and contractors (wykonawcy) by name, with the explicit goal of obtaining their NIP. It also names the downstream tools that consume the NIP, which distinguishes it from sibling search tools such as search_tenders and search_cpv.

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

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

The description gives clear context for when to use the tool: before get_buyer, get_contractor, or search_tenders with buyer_nip, when an entity's NIP is needed. It does not explicitly state when not to use it or name alternatives for the same lookup purpose, so it falls just 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?

The description discloses a known behavioral quirk: the value_min/value_max filters are 'leaky at the API side' and results slightly outside the range can appear. This is valuable beyond what annotations could provide. However, no annotations are provided at all, so the description carries more burden; it doesn't mention pagination behavior, rate limits, or result count limits, but the leak warning is significant.

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 concise and front-loaded: the first sentence states the purpose, the second discloses the known leak caveat, and the rest are examples. The examples are helpful but take up space; still, for a 14-parameter tool they're valuable. It avoids fluff and every part contributes.

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 14 parameters, 0% schema coverage, no annotations, and a large sibling set, the description does a solid job: it gives the source (BZP + TED), warns about leaky filters, and provides three representative example calls covering common use cases. It doesn't document the output schema (but an output schema exists, so that offset applies), nor explicitly state which filters require what conditions, but the examples partially cover that. The lack of explicit date format guidance 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 0%, so the schema only provides property names, enums, and defaults. The description compensates by showing example parameter combinations: search='komputer', city='Kraków', notice_type='ContractNotice'; buyer_nip, cpv, sort; cpv, province, value_min, sort. These examples clarify how filters combine and how sort values work ('newest', 'value_desc'). The description still doesn't explain format of date_from/date_to or the exact meaning of order_kind, but the examples provide substantial guidance.

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

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

The description clearly states the tool's purpose: 'Search Polish public tenders (BZP + TED) with filters.' It uses a specific verb ('search') and resource ('Polish public tenders'), and the mention of BZP + TED adds scope. It also distinguishes itself from siblings like get_tender, which is for retrieving a single tender, and search_entities/search_cpv for other entity types.

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 three concrete usage examples showing filter combinations, which implicitly teach when to use it. It doesn't explicitly state when not to use it or name alternatives, but the examples and the tool name 'search_tenders' make its context clear. It could be improved by explicitly saying 'use get_tender to fetch details for a specific tender ID.'

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