AquaMania — locker room & pool furniture

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 substantial work: it discloses the return structure AND warns that offers #2/#3 are synthetic model projections (+9%/+17%), not real commercial proposals — a critical caveat for procurement use. It does not state read-only/pure-computation guarantees explicitly, keeping it from a 5.

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

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

Two sentences, front-loaded with the calculation purpose and then the output structure; little waste. The parenthetical about replacing synthetic offers is long but earns its place as a usage caveat.

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 compensates for the missing output schema by describing the returned values, and flags the synthetic offers. However, for a 7-parameter calculation engine with 0 required params and 14% schema coverage, the description leaves too much of the input contract unexplained to be 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 only 14% across 7 parameters, yet the description adds no meaning for seats, width, lockers, or the cryptic `concept` enum values (max/bench/bench3/bench4) and `material` options. Only the nested `walls` fields carry schema docs, so the description fails to compensate for the coverage gap.

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

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

States a specific verb and resource (calculate NMCK per art. 22 FZ-44) plus the scope ('по конфигурации раздевалки'), which lets an agent tell it apart from the cart/file-based siblings. It stops short of naming an alternative explicitly, so it is not a full 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 'по конфигурации раздевалки' and 'Без файлов' clauses imply this tool is for configuration-driven calculation rather than file/cart input, which is useful routing context. But there is no explicit when-to-use/when-not or named alternative (e.g. calc_nmck_cart), so the guidance is only implied.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the price source hierarchy (manufacturer price list as source #1), the default coeffs (1.0/1.09/1.17), the computed outputs (3 offers, average, V, homogeneity V≤33%, НМЦК), and notes 'без файлов'. It omits auth/permission or failure behavior, but for a computation-only tool this is largely acceptable.

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

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

Front-loads the purpose and the OR-alternative structure in a compact paragraph with no filler sentences; every clause carries information about inputs, defaults, or outputs. Dense but not bloated, though readability suffers slightly from packing many facts into one block.

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

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

No output schema exists, but the description enumerates the return payload (offers, average, coefficient of variation, homogeneity flag, НМЦК), and all three parameters are covered. No annotations exist to fill gaps, yet the key facts an agent needs to call it correctly 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?

Schema coverage is 100%, so the structured fields already document each parameter (baseline 3). The description adds real value beyond the schema: it clarifies that cart prices come from the manufacturer price list, that items carry the customer's own prices, and it supplies the concrete default coefficient values.

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: computes НМЦК per art. 22 ФЗ-44 for any catalog cart or explicit items, and scopes it to the procurement agent with '(не только раздевалки)'. It implies a cart-variant distinct from the base calc_nmck but never names that sibling, so the differentiation is left partly 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?

Clearly lays out the two mutually exclusive input modes — cart:[{article,qty}] vs items:[{name,qty,price}] — and routes the agent to find_product for article lookup. It does not state when-not to use it or explicitly point to calc_nmck for the non-cart case, so the exclusion side is missing.

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 delivers: it enumerates every terminal status, warns that apiKey is returned ONCE and must be saved, and imposes a rate limit. All are non-obvious behaviors an agent would otherwise get wrong.

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?

Purpose is front-loaded in the first clause, followed by the input source and then a compact status table. Every clause conveys distinct, actionable information 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?

No output schema exists, but the status enumeration effectively documents the response shape (pending/approved/rejected/already_claimed and the apiKey field), leaving no gap for a tool of this complexity.

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

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

Schema coverage is 100% and the schema already defines requestToken as the secret issued by request_api_key, so the description largely repeats rather than extends it. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific compound action (check status AND retrieve the key if approved) on a specific resource, and pins the input to the requestToken issued by request_api_key, cleanly separating it from the sibling that creates the request.

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?

Explicitly ties the token to request_api_key as its source and gives the operating rule for polling (no more than once per 10 minutes), so the agent knows both the prerequisite and the cadence. Nothing about when to call it is left to inference.

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

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

With no annotations, the description carries the full burden. It discloses the return payload (number of lockers, seats, total in ₽, visualization segments) which is genuinely useful given there is no output schema, and 'рассчитать' implies a pure computation. However, it says nothing about permissions, whether any state is persisted by 'configure', or determinism.

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

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

Two tight sentences with zero filler; the primary purpose is front-loaded and the return summary follows. Efficient for the amount of information conveyed.

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 complex calculation tool (nested walls with openings, enum-driven concept/material) the description covers purpose and returns, which partly compensates for the missing output schema and absent annotations. It still omits usage context and any caveats an agent would need to choose it over sibling pricing/quote tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's mention of 'с учётом проёмов' reinforces the openings semantics already documented in the schema but adds no new syntax, units, or constraints beyond what the schema states.

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

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

Specific verb (рассчитать) plus a precise resource (раскладка шкафов для раздевалок по стенам) and an explicit secondary output (цену). An agent can tell this is the locker-room layout/cost calculator, distinguishing it from generic quote or product tools. It does not, however, name any sibling to contrast with, so sibling 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?

The description gives no when-to-use guidance, no prerequisites, and no indication of when an alternative (e.g. list_concepts for width options, or a quote tool) should be preferred. The only cross-reference to a sibling (list_concepts) lives in the schema, not the description.

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 most of it: it discloses the side effect of notifying a manager, the pricing branch tied to account type, and the return payload (order number and total). It does not state whether the order is irreversible or what authentication/permission constraints apply beyond key type.

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?

Four short sentences, front-loaded with the action and pricing semantics, then inputs, then effects and return value. No filler; every clause carries information an agent needs.

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

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

For a mutating create-order tool with no annotations and no output schema, the description is nearly complete: it explains pricing derivation, side effects, and the returned values. It stops short of error behavior or idempotency/duplicate-order semantics, which matters for an order-placement 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 baseline is 3; the schema already documents name, phone, and comment. The description adds modest value by restating the items shape [{article, qty}] and pointing to find_product for article codes, but does not add constraints (e.g., qty bounds, article format) 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 opening sentence names a specific verb and resource ("Разместить заказ от дилера по нетто-ценам") and the closing sentence confirms the effect ("Создаёт заказ, уведомляет менеджера, возвращает № заказа и итог"). This clearly separates it from calculation and quote siblings such as calc_nmck, get_quote, and make_kp.

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

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

It gives concrete usage context: articles must come from find_product, and pricing depends on whether the API key belongs to a dealer account (dealer prices) or not (list prices). It also clarifies that the phone parameter does not affect discounts. What's missing is an explicit when-not or a direct comparison to siblings like get_quote or make_kp.

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 well: it discloses the return fields (description, size), the existence and role of a note warning field, and the non-obvious caveat that price is not a 'baseness' signal. It omits operational traits like result limits/pagination or auth requirements, keeping it at 4.

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 purpose and scope, then matching behavior, then the selection/price caveat. It is a dense single block, but nearly every clause earns its place; only the lengthy price caveat is slightly verbose.

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

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

For a 3-param search tool with no annotations and no output schema, the description compensates by explaining both what it matches and what it returns. Minor gaps remain around result volume/limits, 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 description coverage is 100%, so the baseline is 3, but the description adds real meaning: it clarifies that query matches across артикул (both platform and 1C), name, dimensions and description, and that category/material act as filters. This goes beyond the schema's bare examples.

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 (весь каталог продукции AquaMania), quantifies the scope (162 SKU) and enumerates the searched fields and filters. An agent can immediately tell this is a catalog lookup tool, distinct from the surrounding quote/calculation siblings (calc_nmck, make_kp, get_quote).

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 clear in-context guidance: choose by description/size, and do not treat price as an indicator of a 'basic' model — instead ask the customer when the note flags ambiguity. It does not, however, explicitly state when to prefer this over sibling tools or name an alternative, so it falls short of the 5 threshold.

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 that no files are generated (suggesting a pure computation/read), but says nothing about permissions, cost of computation, or side effects; no output schema exists to fill the 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 front-loaded sentences: the first gives the operation and its key constraint, the second enumerates inputs and the either/or pattern. No wasted 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?

With 7 parameters, zero required, no annotations, and no output schema, the description should say more about valid input combinations and what the returned quote data contains. It gestures at the return ('спецификацию и итоговую цену') but is thin for a tool of this complexity.

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 only 43%, but the description compensates by naming the key inputs (walls/width/material/concept, lockers, seats) and, importantly, explaining the two alternative input modes (configurator params OR explicit locker/seat counts). Only 'name' is 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?

States a specific verb ('Сформировать спецификацию и итоговую цену') and resource (quote/KP data), and the qualifier 'без генерации файлов' implicitly separates it from file-producing siblings like make_kp. Clear but does not explicitly name or contrast any sibling.

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

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

The phrase 'без генерации файлов' hints at when to prefer this over document-generating tools, and the configurator-vs-count input note implies context. However there is no explicit when-to-use vs calc_nmck, quote_project, or make_kp, so usage is only implied.

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

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

No annotations are provided, so the description carries the disclosure burden. It signals that live pricing data is returned ('реальными ценами') and enumerates the concept variants, but says nothing about auth requirements, data freshness, or the response shape. Low-risk because the tool takes no input, so a 3 is fair.

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 content inventory first, then the actionable instruction. No filler, and the 'call first' directive is easy to act on.

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

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

With no output schema and no annotations, the description must explain what comes back, and it does: concepts, bench variants, material-tiered prices, and section widths. Return structure is only loosely implied, which keeps it short of a 5.

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

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

Zero parameters, so the 0-param baseline of 4 applies. The description goes slightly further by naming the vocabulary the agent will need downstream (valid material/width/concept), which is exactly the useful info for a lookup 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?

Names a specific resource (AquaMania locker-room equipment concepts) with concrete variants (no bench / bench for 2/3/4 seats) and the data carried (prices by material ЛДСП/HPL, section widths). This clearly separates it from mutation-only siblings like configure_locker or calc_nmck, though it never names an alternative 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?

'Вызывать первым' gives explicit ordering guidance: call this before deriving material/width/concept. It tells the agent when to reach for this tool but offers no exclusions or named follow-up 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 supplied, so the description carries the full disclosure burden. It does add useful behavioral facts — it produces two document formats and returns downloadable links, and it hardcodes supplier details (ИП Гусев) with real prices — but it says nothing about persistence, side effects, 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?

Two tight sentences that front-load what is produced and how it is delivered. The trailing note on supplier details and real prices is slightly tangential but short, so overall it is efficient.

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

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

With 8 parameters, a nested walls/openings structure, no output schema, no annotations, and 13% schema coverage, the description is far too thin to call this tool correctly. It would need at least parameter-level hints and guidance on which inputs are meaningful for a valid proposal.

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 only 13%, so the schema does not carry the load, and the description must compensate. It only vaguely frames the input as 'параметры раздевалок', adding no meaning for seats, walls, openings, concept, lockers, width, or material — the eight parameters remain largely opaque.

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

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

The description gives a specific verb ('Сгенерировать') and concrete artifacts (коммерческое предложение + ТЗ as docx + xlsx) and says it returns download links — an agent knows what comes out. However, it never distinguishes itself from siblings like make_project, make_tender_package, get_quote, or quote_project, so tool selection still requires guessing.

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

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

There is no when-to-use guidance, no stated prerequisites (e.g. which API key / auth context), and no mention of alternatives among the many make_*/quote_* siblings. The agent is left to infer that this is the proposal-generation path.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the output artifacts (КП + ТЗ as docx/xlsx, returned via download links) and a non-obvious business rule ('Реквизиты — ИП Гусев, цены реальные'), but says nothing about side effects, whether the project is persisted, auth requirements, or how errors (e.g. unknown article) are surfaced.

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

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

Two dense sentences, no filler, and the core action (generate full-object КП+ТЗ from zones) is front-loaded ahead of the secondary detail about requisites and real prices. Slightly overloaded with parenthetical asides but nothing wasted.

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

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

There is no output schema, and the description does cover the return value (download links to docx/xlsx). However, for a multi-zone document generator with nested zone objects, it omits how partial/invalid input is handled, whether a project entity is created server-side, and how it relates to sibling generator tools — leaving real 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 67%, so the schema already documents zones, type, walls, seats, concept, etc. in detail. The description adds only the multi-category framing ('шкафы + стеллажи + скамьи + дорожки'), while the only undocumented parameter (phone) is left unexplained in both places — adequate but not compensating for the gap.

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

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

States a concrete verb and artifact: generate a finished КП + ТЗ (docx/xlsx) for an entire object from zones and return download links. It distinguishes scope ('на объект целиком', 'мультикатегория: шкафы + стеллажи + скамьи + дорожки'), which implicitly separates it from single-category generators like make_kp, but it never names the 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?

Usage is only implied: the agent can infer 'use this when you have multiple zone types and want a full-object package', but there is no explicit when-to-use, when-not-to-use, or pointer to the closest alternatives (make_kp, make_tender_package, quote_project) which all appear to produce overlapping quote artifacts.

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 the output shape (a ZIP containing four documents, returned as a download link), which is genuinely useful since no output schema exists. However, it says nothing about authentication needs, whether generation is idempotent, side effects, or error behavior for a tool that clearly produces artifacts.

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

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

A single dense sentence with the deliverable list and the arrow notation for the output artifact; it is front-loaded and wastes no words. It is perhaps too compressed given the complexity, but structurally it is efficient.

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

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

For a complex 7-parameter generation tool with no annotations, no output schema, and near-zero schema coverage, the description describes only the output and leaves the inputs and invocation context undocumented. It is not adequate for an agent to call this correctly without guessing at parameter semantics.

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 only 14%, so the schema documents almost nothing, and the description does not compensate. It only implies the parameters describe a 'конфигурация раздевалки'; nothing explains name, seats, walls, width, lockers, or the concept/material enums, all of which the agent must call correctly with zero guidance.

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

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

States a specific verb (Собрать) plus the resource (тендерпакет 44/223-ФЗ) and enumerates the exact deliverables (КП, ТЗ, обоснование НМЦК, спецификация) and final artifact (ZIP + download link). This implicitly separates it from make_kp, which produces only the КП, but it never names the sibling make_tender_package_cart or clarifies the distinction, so it stops short of full differentiation.

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

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

There is no when-to-use, when-not-to-use, or prerequisite information. The agent must infer from the name alone whether to pick this over make_kp, make_tender_package_cart, or configure_locker, and nothing tells it what input state must exist first.

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 discloses the API-key requirement (file generation), the output artifact (ZIP with a link), and the fact that the cart must match the one used for calc_nmck_cart. It does not cover failure modes, cost, or latency, but the safety/auth/output profile is well above the annotation-less baseline.

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 paragraph with the deliverable list front-loaded and the sibling routing after it; nearly every clause carries new information. It is somewhat run-on but no sentence 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 enumerating the generated files and the ZIP-with-link return. Combined with the auth requirement and the calc_nmck_cart sequencing, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so cart/name/phone are already documented. The description adds only marginal semantics (articles come via find_product, cart is arbitrary and must match the NMCK cart), which is the expected baseline 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 (собрать) and resource (полный тендерпакет 44/223-ФЗ) plus exact deliverables (КП, ТЗ, обоснование НМЦК, спецификация xlsx, проект контракта, опись → ZIP). The parenthetical 'не только раздевалки' carves out its scope against the sibling make_tender_package, so an agent can distinguish them without opening 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?

Explicitly prescribes the workflow: pair with calc_nmck_cart — compute NMCK first, then assemble the package for the same cart. Also routes article lookup to find_product. Both the prerequisite ordering and the sibling dependencies are spelled out rather than implied.

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

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

With no annotations, the description carries the full burden, and it does disclose an auth prerequisite (an API key issued by a manager for the client/dealer account) plus a useful caveat that statuses are maintained by an AquaMania manager, implying human-updated rather than real-time data. It omits read-only confirmation, error behavior for an invalid key, and any notion of freshness or return format, leaving substantial gaps 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?

Four short sentences, no filler: purpose first, then auth prerequisite, then the argument-dependent behavior, then status ownership. Slightly dense and clipped, but every sentence earns its place and the purpose 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-optional-parameter read tool with no annotations and no output schema, the description covers purpose, data scope, auth requirement, and both invocation modes. The main shortfall is that it never conveys what a returned status looks like or how failures surface, but no output schema exists to shift that burden elsewhere.

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% (orderId documented as the order number from dealer_order), so the schema already establishes the type and source. The description adds real meaning beyond it by explaining that omitting orderId returns a list of recent orders while supplying it returns a single detailed order, which changes how an agent should call 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 states a specific resource and scope: the status of the caller's OWN orders/quotes, with the possessive 'СВОИХ' marking the data boundary. It does not name or contrast with any sibling such as dealer_order or get_quote, so an agent must infer the boundary between creating/tracking an order and reading its status.

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 documents the two invocation modes — no arguments to list recent account orders, orderId to fetch one order in detail — which is genuine usage guidance. However, it never says when to prefer this over sibling tools (dealer_order, get_quote) or when not to call it, so the choice remains implied.

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

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

With no annotations, the description carries the full burden, and it does disclose the return shape (per-zone breakdown, grand total in ₽, total НМЦК) and the 'no files' trait, which distinguishes it behaviorally from package-generating siblings. It says nothing about permissions, side effects, or any persistence, which for a quoting tool is a modest but real 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?

Four compact sentences, front-loaded with the core action and scope, and closing with the output summary. Nothing is wasted, though it could have spent one clause on sibling differentiation.

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 complex nested-input tool with no output schema, the description adequately conveys what comes back (per-zone breakdown, totals, НМЦК). It stops short of telling the agent how this differs from the numerous quoting/packaging siblings, which is the main missing piece.

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 itself documents the nested zone fields (type, walls, openings, concept, material, items). The description adds the conceptual framing of a zone as locker-parametric or catalog-based, which mirrors rather than extends the enum descriptions, 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: calculate an estimate for an entire project composed of multiple zones, and clarifies each zone is either a parametric locker-room calculation or a catalog item set. This scope statement (project-wide, multi-zone) does some differentiation work, but it never names or contrasts a sibling such as get_quote or make_project, so an agent must infer the boundary.

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

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

Usage is only implied: 'Без файлов' suggests this is the pure-calculation path as opposed to the file-producing siblings (make_kp, make_project), and the multi-zone framing hints at the whole-object case. There is no explicit when-to-use/when-not statement or 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 burden and does so well: human review by the platform owner, typical turnaround (business hours, within a day), the returned requestToken and the obligation to save it, the exact permission scope of the issued key, and daily/monthly quotas. Nothing about the write-adjacent consequences is left implicit.

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

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

Front-loads the action and self-service note, then proceeds through trigger, process, return value, permissions and quota in tight em-dash-separated clauses. Every sentence carries unique information and nothing is repeated from the schema beyond what the agent needs in context.

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

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

No output schema exists, yet the description explains the return value (requestToken) and its downstream use, plus review latency and quota. For an onboarding/authorization tool this is complete enough to act on without further discovery.

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 5 parameters is already documented with purpose and required/optional status. The description adds no parameter-level 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+resource ('запросить собственный API-ключ к этому MCP-серверу') and explicitly marks it as self-service. It distinguishes itself from siblings by naming check_api_key_request as the follow-up tool and dealer_order as the one tool the issued key cannot use.

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 an explicit trigger condition — call it when you hit '401 missing_api_key' on a write tool, listing make_kp, make_project and tender packages as examples. It also states the exclusion (dealer_order is handled by a manager), so the agent knows when NOT to expect this route to work.

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