TimeZero Resurrection

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

The annotations supply only readOnlyHint=false, and the description's 'accept the agreement' is consistent with a mutating call, so no contradiction. Beyond that it adds little behavioral context: it does not say whether acceptance is permanent, whether the call is idempotent or fails if already accepted, or what happens to gameplay if it is skipped.

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

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

A single short sentence that front-loads the action and puts the situational cue in parentheses, with zero filler. Nothing could be trimmed without losing the first-login 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?

For a zero-parameter, no-output-schema action this is largely sufficient: the agent knows what it does and the circumstance in which it appears. The main missing piece is the outcome of the call (success/failure, whether acceptance is recorded once), which is minor given the tool's simplicity.

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 no parameter semantics for the description to explain and the baseline applies. Nothing in the description misleads about inputs, and the empty schema matches the description's parameterless framing.

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 resource ('accept the game's user agreement') and adds the concrete UI trigger ('the button in the window on first login'), so the agent knows exactly which action this maps to. It is distinguishable from siblings like game_login and game_register by that first-login-window framing, though it never names an adjacent tool explicitly.

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

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

Usage is implied rather than stated: the parenthetical tells the agent this corresponds to a first-login agreement window, which suggests when it is needed. However, there is no explicit 'call this when X' instruction, no statement of what to do if the window is not shown, and no mention of what becomes possible after accepting.

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

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

Annotations only supply readOnlyHint=false, so the state-changing nature is already declared. The description adds useful context beyond that: the chip comes from the backpack and activates a set perk when enough set pieces are worn. It does not say whether the chip is consumed, what happens if the set requirement is unmet, or whether the effect can be undone.

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 with the mechanic in parentheses — nothing padded. The only structural weakness is that the explanatory clause dominates the guidance an agent actually needs for invocation.

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 mutation tool with no output schema and minimal annotations, the description covers the core action and the set mechanic but omits outcome information (consumption of the chip, success/failure conditions, whether the perk takes effect immediately). 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 0% and the single required parameter item_id has no schema text at all. The phrase 'из рюкзака' (from the backpack) weakly implies item_id is a chip identifier held in inventory, which is some compensation, but no format, source-of-value, or constraint information is given.

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 ('Применить чип специализации из рюкзака' = apply a specialization chip from the backpack) and adds the game mechanic behind set specialization. It is clear what the tool does, though it never explicitly contrasts itself with nearby siblings such as game_use_item, game_equip, or game_implant.

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 explains what a set specialization is, but there is no statement of when to call this instead of game_use_item / game_equip / game_implant, and no prerequisites (chip must be in backpack, required set items must be worn) are stated. The agent has to infer all triggering conditions from the name.

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

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

readOnlyHint=true already covers the safety profile. Beyond that, the description adds a location prerequisite (must be inside a type-2 building) and discloses the shape of the listed entries (id, quantity, requirements), which matters because there is no output schema. Missing only what happens on failure outside the building.

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 with the resource, the location constraint, and the entry fields front-loaded, with zero filler. It is terse to the point of omitting the verb, 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?

For a zero-parameter read tool with no output schema, the description gives enough to call it and to anticipate the returned fields. It falls short on the follow-up path: an agent looking at these items has no pointer to game_arsenal_take for actually acquiring one.

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 there is nothing for the description to disambiguate and the baseline applies. It correctly signals that no filtering arguments are needed to obtain the listing.

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 the specific resource (arsenal warehouse) and its scope — free items with id, quantity and requirements, available only inside a type-2 building. An agent can tell it apart from the write-side sibling game_arsenal_take. The reading verb is only implied rather than stated, which keeps it just short of a 5.

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

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

The parenthetical 'inside building type 2' gives a real precondition for when this tool is callable, which is genuine usage context. However, it never names the alternative — game_arsenal_take is obviously the way to obtain an item, yet the description gives no routing to it or warning about calling this outside the building.

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?

Beyond the readOnlyHint=false annotation, the description discloses a real behavioral trait: the server enforces weight limits and rejects the transfer on overload, returning the backpack state. That failure mode is exactly the kind of information annotations cannot convey, though it does not mention permission requirements or whether a partial transfer can occur.

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

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

A single dense sentence, front-loaded with the action, followed by the parameter meaning and the server-side weight rule. Every clause carries information; only the slightly run-on phrasing 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?

For a three-parameter mutation with no output schema, the description covers the action, both optional parameters, and the rejection/return behavior on failure. Nothing an agent needs to invoke it correctly appears to be missing.

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

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

Schema coverage is 0%, so the description must compensate and largely does: it explains that count selects a number of items versus the whole stack, and that section is the backpack tab with allowed values 0..3. item_id is only implied by context, leaving one minor gap.

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

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

States a concrete verb+resource: taking an item from the arsenal warehouse into the backpack, with the stack-vs-count distinction. It clearly contrasts with reading tools like game_arsenal or game_inventory, though it never names a 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 implied by the phrase 'from arsenal warehouse into backpack', which tells the agent the preconditions (item must be in the arsenal). No explicit when-not guidance or named alternatives such as game_move_item or game_auction_take 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?

The readOnlyHint=false annotation already tells the agent this mutates state, so the description's job is to add context beyond that; the server antibot note ('not frequent') is genuinely useful behavioral context not captured by any annotation. Still missing is what the action risks or produces — whether the player can be injured, whether a battle is initiated, or what a failed attempt returns — which matters for a combat mutation.

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

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

It is a single short sentence with the action front-loaded and the rate-limit caveat attached, so nothing is wasted. The abbreviated parenthetical is terse to the point of being slightly cryptic.

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 parameterless action tool with no output schema, the description covers the essentials plus a rate-limit constraint. It falls short on outcome disclosure — what success or failure looks like for a combat action is never stated, which is the main missing piece for an agent deciding whether to invoke 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?

The tool takes zero parameters and the schema is empty, so the baseline of 4 applies; there is no parameter surface for the description to explain. The description correctly implies the target location is derived from the player's current position rather than passed as an argument.

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 concrete verb (attack) and resource (monsters) plus the required location (a cell or a mine room), so the agent knows this is a location-bound combat action. It does not explicitly contrast itself with combat siblings such as game_battle or game_battle_plan, which leaves some ambiguity about which combat path to take.

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 'on a cell or in a mine room' implies the preconditions for use, and the antibot parenthetical implies a frequency restriction. However, there is no explicit guidance on when to prefer this over game_battle or what to do when the rate limit blocks it.

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?

readOnlyHint=true matches the browse semantics, so no contradiction. Beyond the annotation, the description usefully discloses that the tool is mode-dependent and what each mode surfaces (commission, storage, term vs. a page of 8 entries), but it says nothing about totals, page bounds, or empty-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?

A single front-loaded sentence keeps it short, but the meaning is packed into nested parentheses and telegraphic notation ('s — ресурсы, 1 — мои лоты'), which costs more parsing effort than a slightly longer plain phrasing would. Nothing is wasted, but clarity suffers for the density.

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

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

For a 3-parameter, no-output-schema, read-only tool this covers the essentials — modes, page size, filter format, building prerequisite. It still leaves an agent guessing about the complete `category` value set and about pagination boundaries, which matters because the tool is the only entry point to auction state.

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 carry the load, and it largely does: it explains that `category` selects the mode and gives example values ('s' for resources, '1' for my lots), defines the page size as 8, and gives the `filter` syntax («name:…,type:…»). Gaps remain: the full set of valid `category` values is not enumerated, and `page` is only implied by 'page of 8'.

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 the resource (auction) and pins its scope: it only works inside buildings of type 56, which is a concrete constraint an agent can act on. It does not, however, differentiate itself from the closely related siblings game_auction_buy, game_auction_sell, and game_auction_take, so an agent must still infer that this is the read/browse 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?

Usage is implied only through parameters: call without `category` to get a summary, with `category` to get a paged listing. The 'inside a type-56 building' prerequisite is stated, but there is no explicit guidance on when to choose this over the auction_buy/sell/take siblings, nor what happens if called outside such a building.

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

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

Annotations only declare readOnlyHint=false; the description correctly signals a purchase (consistent with a mutation) and adds the important clarifications that the listed price is per unit and that own listings/bids are excluded. It says nothing about fund deduction, insufficient-money behavior, confirmation steps, or what happens to the lot on failure, which matters for a mutation tool with thin 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 short sentences with no filler; the core action and the exclusivity rule are both front-loaded. The parenthetical about per-unit pricing is dense but 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 only a readOnlyHint=false annotation, the definition should say more about the result of a purchase — money deducted, what is returned, failure modes. It covers the essential 'what' and the 'who can't' but not the transactional consequences, so it is adequate but visibly incomplete for a buying 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 0%, so the description must carry both parameters — it only clarifies count ('для стопки', i.e. stack quantity) and the per-unit pricing model. item_id gets no explanation beyond its name, and the interaction between count and price (total cost) is left implicit, leaving a genuine gap for a 2-parameter purchase 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 and resource ('Купить лот' — buy a lot) and scopes it to the open auction page, which distinguishes it from game_auction_sell, game_auction_take and unrelated buy tools like game_shop_buy. It stops short of naming those siblings explicitly, so differentiation relies on the agent's own comparison.

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?

Provides one real exclusion — own lots and own bids cannot be bought — which is a useful when-not rule. It gives no positive preconditions (must the auction page be open? must funds be available?) and never routes the agent to game_auction_sell or game_shop_buy as alternatives, so guidance is implied 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?

The annotation only says readOnlyHint=false, so the description must carry behavioral weight. It does add one genuinely useful fact — the commission is deducted from the proceeds at sale time — plus the fact that count applies to stacks, but it omits whether the item leaves the backpack immediately, whether a listing can be cancelled or retrieved, and any 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?

A single dense sentence with the core action front-loaded and clarifying detail in parentheses. Nothing is wasted, though the nested parenthetical makes it slightly harder to scan than a two-clause version would be.

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 three-parameter mutation tool with no output schema and minimal annotations, the fee disclosure and price format cover the essentials, but an agent still cannot tell what state change occurs to the inventory item or whether the listing is reversible.

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 supply parameter meaning and largely does: price is per unit and is a string containing a dot as decimal separator, and count applies only when listing a stack. Only item_id is unexplained, which is close to self-evident.

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: listing an item from the backpack on the auction at a fixed price. That verb distinguishes it from game_auction_buy, game_auction_take and the generic game_auction, although it never names those siblings explicitly.

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

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

Usage is implied by the phrase 'from the backpack' and the fixed-price framing, but there is no explicit when-to-use or when-not-to-use guidance and no mention of how this relates to the other auction tools. The commission note hints at trade-offs but is not framed as selection 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?

The annotations only declare readOnlyHint=false, so the mutation nature is already known; the description does add real value by disclosing the monetary consequence — a storage fee charged for every started day. However, it does not say whether the item returns to inventory, what happens if the lot already has bids, or whether the fee is charged at the moment of withdrawal.

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 action verb front-loaded and the cost caveat placed in a parenthetical, so nothing is buried. It is short and efficient, though the parenthetical fee note is packed into the same clause as the action rather than separated.

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 auction tool with no output schema, no parameter descriptions and only a readOnlyHint annotation, the description leaves important gaps: destination of the withdrawn item, behavior with existing bids, and the meaning of 'count'. Only the storage-fee consequence is covered.

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 carries the full burden, yet it only loosely implies that 'лот' maps to item_id and says nothing at all about the optional 'count' parameter (e.g. quantity when withdrawing a stack) or about the item_id format. An agent must guess the meaning of half the 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?

The description states a concrete verb ('Забрать' = retrieve/take back) and a concrete object ('свой лот' — your own lot) scoped to the 'Мои вещи' page, which clearly separates it from game_auction_sell, game_auction_buy and game_auction. It is specific enough that an agent knows it is a withdrawal-of-own-listing operation, though it never names those siblings explicitly.

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

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

Usage is only implied: the phrase 'свой лот со страницы «Мои вещи»' tells the agent it applies when you already have a lot listed, but there is no explicit when-to-use/when-not guidance, no preconditions (e.g. whether bids exist on the lot), and no pointer to alternatives such as cancel-vs-sell flows.

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

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

Annotations already declare readOnlyHint=true, so safety is covered, and the description adds real value beyond that by enumerating the returned payload fields, which matters because there is no output schema. The only noted side behavior is that with_map extends the response with the surrounding map. It does not describe failure behavior (e.g. what happens outside combat), which keeps 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?

One compact, front-loaded sentence: the resource first, contents next, the parameter last after a semicolon. No filler. It is dense to the point of telegraphic (abbreviation 'ОД', clipped phrasing), which slightly trades readability for brevity.

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-required-param read tool with no output schema, the definition covers the important ground: it tells the agent what the response contains and what the one flag does. The remaining gap is the absence of any precondition or error context (must a battle be active?), which is minor given the tool's simplicity.

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

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

Schema description coverage is 0% and the single parameter has no description, so the description must compensate. It does explain with_map as 'карта вокруг' (map around), giving the flag concrete meaning, but the wording is terse and doesn't state cost, size, or default behavior when omitted.

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?

Opens with a specific verb+resource ('Состояние боя' = battle state) and enumerates exactly what the state contains: turn, seconds, action points, enemies with distance, fog visibility, weapon modes, loot, plan. That lets an agent recognize it as the read-side counterpart to siblings like game_battle_plan, game_battle_submit and game_battle_clear without opening the schema, though it never names those siblings explicitly.

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

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

Usage is only implied: an agent infers 'call this to read battle state' from the description itself. There is no explicit when-to-call guidance, no mention of prerequisites (e.g. must be in an active battle), and no routing to alternatives such as game_battle_plan for planning or game_battle_submit for acting.

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 annotation readOnlyHint=false correctly signals a mutating operation, and the description is consistent with that — it discards something. It adds real context beyond the annotation by stating that only the *unsent* plan is cleared, implying no committed battle data is lost. It stops short of saying whether the operation is reversible or what errors occur when there is nothing to clear.

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

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

A single short sentence with the destructive verb front-loaded and zero filler. It is efficient, though at this length it comes across as under-specified rather than deliberately terse, which keeps it just below 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?

For a zero-parameter, no-output-schema tool this covers the essential minimum: what it clears and that the target is unsent. It is not fully complete — it says nothing about the post-clear state, error conditions, or how it relates to the surrounding battle_plan/battle_submit tools, which matters in a 70-tool sibling set.

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; the baseline of 4 applies. The description does not need to explain any argument shapes and correctly stays silent on them.

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 plus object ('Очистить неотправленный план хода' = clear the unsent turn plan), which an agent can map directly to the battle planning workflow. It does not explicitly name the sibling tools it differs from (game_battle_plan, game_battle_submit), so true sibling differentiation is left to inference, but the phrase 'unsent' still separates it from submit.

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 word 'неотправленный' suggests you call this when a draft plan exists but has not been submitted. There is no explicit when-to-use statement, no mention of alternatives such as editing the plan via game_battle_plan or sending it via game_battle_submit, and no note on what happens if no draft exists.

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

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

Annotations only supply readOnlyHint=false, so the description carries the disclosure burden and does well: it states the client validates AP, path, ammo and zones, and warns that take_on/take_off mid-battle have a real consequence (medkits and barriers only apply from hand). It never says whether an invalid action rejects the whole batch or whether the plan persists until submit, so the mutation semantics remain partly opaque in a way annotations cannot cover.

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 and the remaining text is a tightly packed semicolon list where each entry earns its place with a required-parameter signature plus a qualifier. It is dense to the point of being hard to scan and some parenthetical asides compete with the operational notes, but there is no filler.

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

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

For a nested array of 14 action variants with no output schema and no field descriptions in the schema, the description supplies nearly everything an agent needs to construct a plan, including the in-hand and adjacent-cell constraints. The gaps are the omitted "getall" action and the absence of any statement about validation failure behavior or plan lifecycle.

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 only one top-level parameter, but it is a 14-variant discriminated array whose fields are undocumented in the schema, so the type→fields mapping in the description (move{bx,by}, shoot{target,fire_type,zone,weapon_id?}, take_on{item_id,slot}) is genuinely additive. It is nonetheless incomplete: the enum contains "getall", which the description never mentions, and bx/by units or coordinate ranges are left unexplained.

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

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

A concrete verb+resource ("add actions to the turn plan") followed by an enumeration of every action variant, so an agent immediately knows this builds a battle plan rather than executing one. It does not explicitly distinguish itself from siblings like game_battle_submit / game_battle_clear, which the plan/review/submit workflow implies but never states.

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?

Per-action notes encode usage conditions (e.g. heal requires the item to be in hand, pickup targets an adjacent cell, away only after the sector is cleared), which is useful when-to-use guidance at the action level. However, there is no statement of when to call this versus game_battle or game_battle_submit, nor whether the plan must be finalized by another 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?

The readOnlyHint=false annotation already signals a mutation, and the description adds a genuine behavioral fact beyond it: the server accepts exactly one submission per turn. It still omits what happens on a duplicate submit (error vs. overwrite), whether a plan must exist first, and what the call returns, which matters for a state-mutating tool with minimal annotations.

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

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

A single short sentence with the action and its key constraint front-loaded. No filler, no redundancy, and nothing that could be trimmed 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 zero-parameter battle action the description covers the what and the per-turn limit, but it does not describe the expected game-state context (plan must be prepared via game_battle_plan, must be in battle) or the response. In a 70-tool game API, that missing sequencing context is a real gap.

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

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

The tool takes zero parameters, so there is no parameter meaning to add beyond the empty schema. Baseline for a no-parameter tool 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 concrete verb and target: send the turn plan to the server. The parenthetical 'one time per turn' clarifies the action rather than merely restating the name. It does not explicitly name game_battle_plan as the prerequisite sibling, so differentiation 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?

The phrase 'один раз за ход' (once per turn) is a real usage constraint that tells the agent not to call it repeatedly. However, there is no explicit instruction on ordering relative to game_battle_plan or what to do instead when a plan has already been submitted, leaving sequencing to inference.

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

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

Annotations only declare readOnlyHint=false, so the description must carry the behavioral weight. It adds one genuinely important fact — "Попытка одна" (a single attempt) — which signals irreversibility, but it never says what happens on a wrong answer (lockout, kick, account flag) or what a successful submission returns.

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

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

Two short sentences, front-loaded with the action and source, closed with the critical one-attempt constraint. Nothing is wasted and nothing is buried.

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

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

Given a single-parameter mutation tool with no output schema, the definition covers trigger and attempt limit, which is most of what an agent needs. The missing piece is consequence-of-failure behavior, which matters a great deal for a one-shot submission tool.

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

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

Schema description coverage is 100% and the single parameter is already fully documented as an integer answer. The description reinforces that this is a numeric answer to the check-task but adds no format, range, 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.

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

The description names a specific action (answering a check-task) and pinpoints its source: issued at login or in-game via the event feed with type "проверка". This differentiates it reasonably well from the other answer-style siblings (game_dialog_answer, game_duel_answer), though it 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?

The trigger condition is implied clearly enough — use it when a verification task appears at login or in the event feed. However, there is no explicit comparison to sibling tools and no guidance on what to do when no such task is pending, so 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?

Annotations supply only readOnlyHint=false, so the description must carry behavioral weight, and it does add two real traits: recipient eligibility and a rate limit ("Частота ограничена"). However, it gives no specifics on the limit, no indication of what error or outcome occurs when the recipient is ineligible, and no delivery confirmation semantics, leaving meaningful gaps for a send operation.

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 short sentences with the core purpose front-loaded and the eligibility restriction immediately after. Slight redundancy with the schema's login description costs it a point, but there is no filler.

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

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

For a two-parameter chat tool with no output schema, the description covers purpose, recipient restriction, and rate limiting — enough to call it correctly. The length cap and content restrictions live in the schema, so their absence here is acceptable, though the lack of any error/failure behavior 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%, with both login and text fully documented including the 240-character cap and the no-links/no-markup rule. The description's recipient constraint largely restates the login field's own schema description, so it adds little meaning 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?

"Личное сообщение" names the resource and implies the send action, and the eligibility sentence makes clear this is a directed one-to-one message rather than a broadcast. It never names the sibling game_chat_say, so the agent must infer the contrast with public chat from the word "private" alone.

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

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

The description states a concrete precondition for initiating a conversation — the recipient must have written to your character first, or be a battle neighbor — which functions as an explicit when-you-may-use rule. It stops short of naming game_chat_say as the alternative for open/public messaging, so the routing decision is only partly supported.

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?

Goes well beyond the single readOnlyHint=false annotation: it discloses throttling, that identical repeated text is dropped, and that the server gives no mute feedback so a success response does not guarantee delivery. That last point is exactly the operational caveat an agent needs. It stops short of saying what the actual response looks like or how long a throttle lasts.

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 short clauses, each carrying distinct information (channel, targeting, rate-limit, delivery ambiguity), with the channel named first. No filler or restatement of the tool name.

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

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

For a two-parameter chat tool with no output schema, the definition covers channel scope, targeting, throttling, and the unreliability of a success signal. The one residual gap is that it does not say what a rejected duplicate or throttled call returns, which matters because the tool cannot be trusted on its response alone.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: `to` targets a nearby player yet the line is still seen by everyone in the location, which is a non-obvious visibility rule not in the schema. The content restrictions on `text` are left to the schema to state.

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 destination ('Сказать в чат локации') plus the meaning of the optional `to` parameter, so the agent knows this posts to the location channel rather than a private one. It never names the obvious siblings game_chat_private or game_talk, so the differentiation is inferred from the scope wording rather than explicit.

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

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

'В чат локации' and 'to — обращение к игроку рядом' imply the local, public-chat use case, and the duplicate/rate-limit note implies when a call will silently fail. There is no explicit 'use game_chat_private instead when…' routing, so an agent must infer the boundary from the word 'локации'.

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

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

Annotations only say readOnlyHint=false, so the description carries the behavioral burden and does add real value: it discloses the cost (copper per item), the transformation (figure swap on set pieces), and that the server validates the design pair. It leaves out failure modes — insufficient funds, partial success across the item list, or whether the original items are consumed — which would have earned 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?

One dense sentence that front-loads the location and action before the price and validation details; every clause carries information. It is a single long sentence with parenthetical and semicolon clauses, which is slightly harder to parse than a short structured breakdown.

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 mutation with no output schema, the description covers location, effect, price model, and server-side validation — enough to call it correctly. The main missing piece is cost magnitude and what the caller observes on partial or failed conversion.

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

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

Schema coverage is 0% and the single array parameter is undocumented, so the description must supply meaning. It does clarify that the ids refer to set items held in the backpack, but it never mentions the practical limits encoded in the schema (1–8 ids per call) or whether a mixed male/female set is permitted.

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+resource: converting armor set items from the backpack to the opposite character figure (male ↔ female) at the city hall. The scope (inside building type 7) is made explicit. It does not name a related sibling such as game_setup_silhouette or explain how the two differ, 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?

Gives a clear precondition for use — the agent must already be inside a building of type 7 — and implicitly the items must be in the backpack. No explicit when-not guidance or named alternative tool is provided, which keeps it out of the top band.

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?

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context beyond that. It does not say what happens when no dialog is open (error vs empty), whether the call is idempotent, or that the returned options map to game_dialog_answer inputs — a meaningful gap for a stateful game-dialog flow.

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

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

One short, front-loaded sentence with no filler or redundancy. It is appropriately sized for a zero-argument read call, though its brevity is also the source of the missing guidance rather than a model of density.

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

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

For a no-parameter, read-only tool with no output schema, the description covers the core action adequately. It omits two things an agent needs in a dialog workflow: the 'no open dialog' condition and the handoff to game_dialog_answer for submitting a choice.

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 there is nothing for the description to disambiguate; baseline 4 applies. The absence of arguments itself communicates that the tool operates on the player's current dialog state, though the description does not say so explicitly.

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 resource in Russian: 'Показать открытый диалог с вариантами ответа' — show the open dialog with response options. An agent knows it retrieves a pending dialog, but the description never mentions the sibling game_dialog_answer, which is the natural next step, so sibling differentiation is absent.

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 guidance on when to call it versus alternatives, no mention of the prerequisite (a dialog must actually be open), and no pointer to game_dialog_answer for replying. Usage must be inferred entirely from the name.

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

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

The annotations declare readOnlyHint=false, so an agent already knows this is a mutation, but the description adds nothing about what the mutation does: whether the dialog advances or closes, whether the choice is irreversible, or whether any state is consumed. For a decision-making write action, the most important behavior, that the choice is committed, is left implicit in the verb 'выбрать'.

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

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

It is a single, front-loaded sentence with no filler, and the placement of the parameter hint in parentheses is efficient. It is minimal to the point of under-specification, but nothing in it 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 and no parameter descriptions, the description must carry the full burden, and it does not: it never says whether the tool returns the next dialog node, a success flag, or side effects such as rewards or quest updates. For a mutation tool that gates narrative progress, that gap matters.

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

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

Schema description coverage is 0% and option_id carries only a type and a maxLength, so the schema contributes no meaning. The description compensates by saying the id comes from game_dialog, which is genuinely useful provenance. It still omits format expectations, such as whether this is an index, an opaque token, or a label, and whether stale ids are rejected.

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 resource in 'Выбрать вариант в открытом диалоге', and it ties the target to the sibling that produces it ('id варианта из game_dialog'), so an agent can separate this from game_dialog. It loses a point only because the term 'открытый диалог' assumes dialog state that the description never spells out for an agent that is unfamiliar with the game.

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 states an implicit prerequisite: a dialog must already be open, and the option_id must come from game_dialog. It offers no explicit when-not guidance and does not distinguish this tool from the other *_answer siblings (game_challenge_answer, game_duel_answer).

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

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

Annotations provide only readOnlyHint=false, so the description carries the burden of disclosing behavior. 'Close connections' hints at the side effect, but nothing is said about whether the session/state persists, whether re-login is possible, or what happens to in-progress game actions. For a disruptive disconnect operation this is a substantial gap.

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

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

A single front-loaded sentence with the core action first and a clarifying parenthetical, with no padding. It is arguably too terse rather than verbose, which costs it nothing on this dimension.

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 only a single weak annotation, the description must explain the consequences of disconnecting — session invalidation, re-login requirement, effect on ongoing game state. None of that is present, leaving an agent unable to predict what happens after the call.

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 4 applies. No parameter-related content is needed or missing.

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 ('Выйти из игры' — leave the game) and adds the concrete mechanism in parentheses ('закрыть соединения' — close connections). This is enough to separate it from game_login, though the terse phrasing and the language mismatch with the English sibling names slow recognition slightly.

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

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

There is no indication of when to call this versus alternatives (e.g., game_leave_building, game_wait) and no prerequisites or exclusions. The agent must infer entirely from the name that this is a session-termination operation.

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

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

Annotations only declare readOnlyHint=false, so the description must carry the behavioral load. It does disclose the consequence of each value (start the fight vs. decline), which is genuinely useful, but says nothing about reversibility, preconditions (e.g., an outstanding challenge must exist), or what happens after the duel is started.

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

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

One short sentence, front-loaded with the action and followed by the value semantics; no filler whatsoever.

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-boolean tool with no output schema, the definition covers the action and both value outcomes adequately. It lacks only post-acceptance flow context (e.g., that battle actions follow), which is a minor gap for such a simple 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 0% and the single boolean has no field-level description, so the description must compensate — and it does, mapping true to starting the battle and false to refusing. It stops short of noting whether omission is possible or error 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?

The description names a specific verb and resource — responding to a duel challenge — and immediately explains the outcome of each branch. It does not explicitly distinguish itself from nearby siblings like game_duel_challenge or game_duel_cancel, though 'respond to a challenge' implies the inbound direction.

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 it is called when a duel challenge is pending, but there is no explicit when-to-use framing or routing against game_duel_cancel (withdrawing one's own challenge) or game_challenge_answer. The two accept values are the only guidance 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?

With only readOnlyHint=false provided, the description usefully adds that the pending challenge has no timeout, so cancellation stays possible indefinitely until an answer arrives. It does not say what happens to the pending challenge record after cancellation, nor whether cancelling after an answer fails with an error.

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 action first and the condition second; no filler or redundant restatement of the tool name.

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

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

For a simple zero-parameter tool with no output schema this is close to sufficient, but the agent is left unsure of the success/failure outcome (e.g., behaviour when the target already answered) and whether anything else is affected by the cancellation.

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 for 0 params applies. The description correctly does not invent parameter detail.

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 ('Отменить свой вызов на дуэль'), making the mutation target unambiguous. It implicitly separates this from game_duel_challenge (creation) and game_duel_answer (responding) through the word 'cancel', though it never names either 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 precondition 'пока цель не ответила' clearly defines the window in which this tool is valid, which effectively tells the agent when not to use it. It does not name an alternative action (e.g., game_duel_answer) for the case where the target has already responded.

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?

Beyond the single readOnlyHint=false annotation, the description discloses two non-obvious behavioral traits: the target player must confirm, and while the challenge is unresolved, world movement steps are blocked. That side effect is exactly the kind of context annotations cannot convey. It stops short of describing failure modes, cooldowns, or what the caller receives.

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 compact sentence with the action front-loaded and the prerequisites in a parenthetical. Every clause carries information; nothing is redundant. Slightly dense punctuation, but appropriate for the amount of constraint 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 mutating one-parameter tool with no output schema and only a readOnlyHint annotation, the description covers timing, location, and blocking behavior well. The remaining hole is the parameter's meaning and validity conditions, which an agent needs to call it correctly.

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

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

Schema description coverage is 0% for the single required parameter 'login', so the description carries the full burden. It never identifies 'login' as the opponent's login or constrains it (e.g., must exist, must be online, must be co-located). The phrase 'Вызвать игрока' implies a target but leaves the parameter's identity and validity rules to inference.

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 in Russian ('Вызвать игрока на дуэль с подтверждением'), which is clearly a challenge action distinct from the sibling game_duel_answer and game_duel_cancel. It does not explicitly name those siblings as alternatives, but the action itself is unambiguous.

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

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

Strong preconditions are given: call only after game_player_info, no sooner than one second later, and only when both players are on the same cell outside the Ocean dome. What is missing is guidance on when to prefer this over related duel tools or what to do if the challenge is declined, but the when-to-use conditions are unusually 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?

Annotations only declare readOnlyHint=false, so the mutation nature is already known; the description usefully adds the positional precondition (you must already be on the cell). It says nothing about what entering triggers (a dialog, a menu, a state change), what failure looks like, or whether the action is reversible.

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 with no filler, and the action is front-loaded before the precondition and the parameter source. The referential phrasing ('по его Z') is slightly compressed but still parseable for an agent familiar with game_look.

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 action tool with no output schema and minimal annotations, the definition covers the action, the precondition, and the parameter source. It leaves the agent guessing about the post-entry state and error conditions, which matters for an irreversible-feeling game action.

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

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

Schema coverage is 0% and the schema only says 'integer, minimum 1', so the description carries the burden — and it does, by telling the agent where the value comes from ('its Z from game_look'). That is meaningfully more than the schema provides, though it does not clarify the coordinate's origin or valid range beyond minimum 1.

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 + object: 'enter the building' on your current cell. It also implicitly contrasts with game_leave_building by naming the entry action rather than the exit, so an agent can distinguish intent. It stops short of explicitly naming a sibling as the alternative.

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

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

The description supplies a real precondition — you must be standing on the cell ('на своей клетке') — which is genuine when-to-use context not available from the schema. It does not state what to do if no building is present, nor does it point to a fallback tool such as game_look or game_move when the precondition fails.

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

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

Annotations only supply readOnlyHint=false, so the description carries most of the behavioral burden; the parenthetical that occupied slots are freed by the client is genuinely useful, disclosing that equipping may displace an already-worn item. It does not state what happens on an invalid item_id, whether the item must be in inventory, or what is returned, but the key mutation side effect is covered.

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

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

Two short sentences, with the action and its side effect front-loaded before the parameter note. Nothing is padded and the parenthetical is doing real work rather than restating 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 two-parameter mutation with no output schema and only a readOnlyHint annotation, the description covers the replacement behavior and the ambiguous slot argument, but says nothing about item_id semantics, failure modes, or the resulting state. It is adequate but leaves gaps an agent would hit when calling 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 0%, so the description must compensate, and it does explain the non-obvious parameter: slot is a single slot letter ('буква слота') needed only when multiple slots are possible. item_id, the one required parameter, gets no explanation of format or source at all, leaving half the parameters undocumented.

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

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

The verb 'Надеть' (equip) plus the object 'предмет' (item) states the action concretely and separates it from siblings such as game_unequip and game_use_item. It does not explicitly name those siblings, but the purpose 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: an agent infers this is for wearing an item that is presumably in inventory, and the clause 'if there are several options' hints when the slot argument is needed. There is no explicit when-to-use versus game_use_item, game_move_item, or game_unequip, and no stated preconditions.

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

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

Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. However, the word "новые" implies a stateful cursor — reading may consume or advance past the events — and the description never confirms this, nor does it mention blocking behavior, ordering, or what happens when no events exist. For a polling tool, delta/consumption semantics are the single most important behavior to disclose.

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

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

A single short sentence with the verb and resource front-loaded and no filler. It is efficient, though the parenthetical event list is the only structural element and everything else about the tool is absent rather than 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?

There is no output schema, no parameter documentation, and no annotations beyond readOnlyHint, so the description carries most of the burden — yet it omits return shape, event ordering, cursor/consumption behavior, and the meaning of `limit`. For a tool whose whole purpose is consuming an event stream, this leaves critical call-time decisions 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 0% for the single `limit` parameter (integer 1–200), and the description does not mention it at all. The agent cannot tell from either source what limit controls (event count? byte cap?), its default, or what happens when it is omitted, so the description fails to compensate for the schema gap.

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

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

The description gives a specific verb+resource ("Прочитать новые события игры" – read new game events) and enumerates the event categories (server messages, combat, NPC, inventory), which makes the tool's scope immediately recognizable. It does not name or contrast with any of the ~70 siblings such as game_look or game_status, so the differentiation 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 explicit when-to-use guidance, no statement of when not to use it, and no reference to an alternative tool for polling versus inspecting state. An agent must infer from the word "новые" (new) that this is a polling/delta-fetch tool, and nothing tells it whether it should be called before or after actions like game_move or game_attack_monsters.

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 readOnlyHint=false annotation already tells the agent this mutates state; the description adds only that the operation happens in the hospital and is free. It does not disclose whether the shifts must net to zero (the example happens to sum to 0 but this is never stated), whether the operation is reversible or limited in frequency, or what the response contains. For a stat-mutating tool with a single weak annotation, that leaves the important behaviour undisclosed.

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 context (hospital, free) before the parameter example. Every clause carries information, though the inline example partially duplicates what the schema pattern already constrains.

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 required parameter, no output schema, and only a readOnlyHint=false annotation, the description needs to explain preconditions, the zero-sum/valid-key rules, cost and limits. It conveys location and cost but omits the constraints that determine whether a call will succeed, leaving the agent under-equipped for a mutating operation.

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 carry the parameter meaning, and it does partially: the sample value «str:81,dex:-9,int:-15,pow:-39,acc:-12,intel:-6» shows the comma-separated key:value syntax and implies signed deltas rather than absolute stats. It stops short of explaining that the numbers are delta shifts, that str/dex/int/pow/acc/intel are the only valid keys, or that the deltas must sum to zero — the format itself is already enforced by the regex, so the added value is mainly the worked 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?

The description identifies the feature ('Генетика в больнице') and the effect ('перенос параметров один в один' — a one-to-one redistribution of stats), which is more than a restatement of the name. However, it never states a concrete verb for what the call does (apply/perform the operation) and gives no differentiation from close siblings such as game_implant, game_hospital_cure, or game_implant_charge, so an agent must guess whether this is the genetics step or the cure step.

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 'бесплатная операция' and 'в больнице' hint at a location precondition and that it costs nothing, which is mildly useful. There is no explicit when-to-use versus alternatives (e.g. implant vs hospital cure), no stated prerequisites (level, being inside the hospital building), and no exclusions.

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

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

Annotations only declare readOnlyHint=false, so the description carries real weight here: it discloses the copper cost, the multi-minute duration, and the cancellation rule tied to leaving the building. It leaves one gap: "котировка" suggests a price quote, yet it is unclear whether the call charges immediately or returns a quote first.

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 action and location front-loaded, followed by cost/effects and then the interruption caveat. Slightly dense phrasing ("котировка и полный курс за медь") requires a second read, 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?

For a parameterless, no-output-schema mutation, the description covers cost, duration, cancellation and healed conditions, which is most of what an agent needs. Missing only failure behaviour (no copper, not inside a type-5 building, already at full HP).

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

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

The tool takes zero parameters, so the description has nothing to disambiguate beyond confirming the call is argument-free. Baseline 4 applies for a parameterless 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 concrete verb (being treated) and resource (hospital, inside building type 5), and enumerates exactly what it restores: HP, knocked-out slots and poisoning. It distinguishes itself from generic healing siblings such as game_use_item implicitly via the building-type prerequisite, but never names an alternative, 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?

Gives a clear precondition (must be inside a type-5 building, which implies game_enter_building first) and a usage constraint (treatment runs several real minutes and leaving the building aborts it). It does not mention alternatives such as healing via items or whether partial treatment is possible.

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

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

Annotations only give readOnlyHint=false, so the description carries nearly the full burden. It confirms the tool mutates state (implant/remove), but says nothing about what removal destroys, whether the implant returns to inventory, costs, or failure conditions. The mutation profile is the minimum available from the name plus annotations.

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

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

One short sentence with the two modes front-loaded and parameter pairing parenthesized. Very little waste, though brevity comes at the cost of the missing usage and parameter detail.

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

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

A mutation tool with no output schema, no annotations beyond readOnlyHint=false, and completely undescribed parameters; the description is too thin to let an agent fill insert/slot/delete correctly or predict consequences. It should document the parameter meanings and the effect of deletion.

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

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

Schema description coverage is 0% and the three parameters are opaque one-letter/256-char strings ('slot', 'insert', 'delete'). The description only hints that insert pairs with slot and delete is the removal identifier; it doesn't explain what goes into insert/delete (implant name? inventory ID?) or what slot refers to.

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

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

The description states a specific verb+resource ('вживить имплант' / 'удалить') scoped to a hospital building, and disambiguates two modes (insert+slot vs delete). It doesn't differentiate from close siblings like game_hospital_cure, game_implant_charge, or game_genetic, which an agent could easily confuse with implant work.

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

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

It implies when each mode is used by mapping parameters to the two operations, but there is no explicit 'use this rather than game_implant_charge / game_hospital_cure' guidance. No stated prerequisites (being in the hospital, needing an implant item, cost) beyond the venue name.

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

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

Annotations only declare readOnlyHint=false, so the description carries most of the load. It discloses meaningful behavior: the action costs copper equal to the implant's price and the result lasts 30 days, and it must occur at a hospital. It does not mention permissions, failure modes, or what happens if the implant is not installed, but for a one-parameter tool this is solid 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 compact sentence with the location front-loaded and cost/duration parenthesized at the end; nothing is wasted. It is arguably over-terse given the undocumented item_id, but structurally it is clean and 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?

With one parameter, no output schema, and minimal annotations, the description covers location, cost, and duration well but leaves the meaning of the required argument unresolved. An agent knows what the tool accomplishes and its price, but not exactly which identifier to pass.

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

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

Schema description coverage is 0% for the single parameter item_id, so the description must compensate and does not. It never clarifies whether item_id is the ID of the implanted implant, the implant item in inventory, or something else, nor its format beyond the 256-character cap in 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 gives a specific verb ('зарядить' = charge) and a specific resource ('вживлённый имплант' = implanted implant), prefixed with the location 'Больница' (Hospital). This lets an agent distinguish it from siblings like game_implant (installing an implant) or game_hospital_cure, though it does not name those siblings explicitly.

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

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

The 'Больница:' prefix implies the player must be at the hospital and have an implant already installed, and '(медь по цене импланта, 30 дней)' adds the cost and duration of the effect. There is no explicit statement of prerequisites, failure conditions, or an alternative tool to use instead, 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?

The readOnlyHint annotation already establishes this is a safe read, so the description's burden is lower. It adds value by naming the fields returned, but says nothing about ordering, size, or whether section=0 means all tabs, leaving behavioral detail thin.

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 clauses, front-loaded with the resource and field list, with no filler. The brevity is efficient though it borders on being too terse for the undocumented parameter.

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

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

With one optional parameter, no output schema, and a read-only annotation, the definition covers the essentials of what data comes back. The unexplained 0-3 enumeration for section remains the notable gap for correct invocation.

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

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

Schema description coverage is 0% for the single 'section' parameter, so the description must carry the load. It only says section restricts output to one tab, without explaining the 0-3 range or which tab each value maps to, which is the key information an agent needs.

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 the resource (backpack and equipped items) and enumerates the returned fields (id, names, quantity, quality, slots, requirements), which is concrete. However, there is no explicit verb and no differentiation from likely-overlapping siblings such as game_arsenal or game_status, so an agent cannot easily tell which inventory-style tool to pick.

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

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

The second clause implies the section parameter narrows results to a single backpack tab plus equipped items, which is the only usage hint. There is no statement of when to call this versus game_arsenal/game_look, and no 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?

Annotations supply only readOnlyHint=false, so the description carries most of the burden. It does not say whether opening the window requires a location check, whether it changes any game state, whether it can fail, or how the sell flow continues afterwards.

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 naming the action and the target; nothing redundant or padded. It is appropriately sized for a no-parameter navigation 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 zero-parameter tool with no output schema, the definition is minimally viable: an agent knows what opens, but not the preconditions or what the opened window exposes. A short clause about location requirements or the follow-up sell action would close the gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate at the parameter level. Baseline 4 applies for a no-parameter 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?

The description gives a specific verb plus resource in Russian ('Открыть окно скупщика Алекса Калиты') and names the NPC and the location context (public factory of New Moscow). It implicitly distinguishes itself from game_kalita_sell (opening the interface vs. selling), but 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?

No guidance on when to call this instead of game_kalita_sell or the generic game_vendor_buy/game_shop tools. There is also no mention of prerequisites such as needing to be physically at the public factory or having previously entered the building.

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?

readOnlyHint=false already flags this as a mutation, so the description only needs to add context — and it does, disclosing the restriction that only items on Kalita's list are accepted and that a price lookup precedes the sale. It does not say whether the sale is reversible, what happens if the item is not on the list, or what a failed attempt returns.

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 with the action front-loaded and the constraint appended. Slight loss for the terse 'сначала его цена, потом продажа' clause, which is ambiguous about whether the price call is mandatory or merely descriptive.

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 mutation with no output schema, the definition covers purpose, the accepted-item restriction, and the two-step flow. The main remaining gap is the unstated dependency on the Kalita dialog being open and on how to discover the item id.

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

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

Schema description coverage is 0% for the single item_id parameter, so the description must carry the load. It partially does by implying item_id must identify something on Kalita's list, but it never explains the identifier format or where to obtain a valid item_id (e.g. from inventory or game_kalita_open).

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 ('Продать вещь Калите' – sell an item to Kalita) and adds a scope constraint ('берёт только вещи своего списка'). It does not name the neighbouring sell tools (game_shop_sell_resource, game_auction_sell, game_vendor_buy), so an agent must infer the distinction from the NPC name alone.

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

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

The phrasing 'сначала его цена, потом продажа' hints at a price-check-then-sell sequence, which is useful implied guidance. However, no explicit prerequisites are stated (e.g. whether game_kalita_open must be called first) and there is no statement of when not to use this versus another sell 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?

readOnlyHint=false is consistent with a state-changing action, and the description adds real behavioral context beyond the annotation: the mine can only be exited from room 0. It does not say where the player ends up, whether the action can fail otherwise, or whether it costs anything.

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

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

One short sentence with the primary action stated first and the exceptional constraint in parentheses. 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 zero-parameter state-changing tool with no output schema, the description covers the action and its one known special case. Minor gaps remain: the resulting location after exit and any failure conditions are 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

The description gives a specific verb+resource: leave the building to the street. That is clearly distinct from the inverse sibling game_enter_building, even though the sibling is not named explicitly.

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

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

Usage is implied — call it when you are inside a building and want to be outside — and the parenthetical adds one concrete condition (from the mine, only from room 0). There is no explicit statement of when not to use it or which sibling to use instead (e.g., game_move for movement indoors).

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?

Only readOnlyHint=false is supplied, so the description carries most of the burden. It does add real behavioral value: this call mutates state and establishes a session, requires a challenge-response round trip, and that the session is not durable across restarts or transfers. It says nothing about what happens on a wrong password, whether repeated incorrect answers are rate-limited or lock the account, or what a successful result looks like.

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 short sentences with zero filler. The purpose comes first, the follow-up mechanism comes second, and the failure and re-entry cases come last. The dense enumeration of the disconnect, restart, idle and transfer cases is efficient rather than 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?

There is no output schema, so return behavior matters. The description explains the challenge response but not what a successful login yields, such as a token, a session or character state, and it says nothing about failure modes. For a 3-parameter authentication entry point, the coverage of the session lifecycle is decent, but the response contract is missing.

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

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

Schema coverage is 100%, so the baseline would be 3; however, the description earns more by explaining the sequencing of the answer parameter. The first call is made without answer, and the second call must carry it, which the schema alone does not convey. The login and password parameters are left entirely to the schema, which is acceptable at full 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 action and target: log into the game as a character, and adds that the call is two-step (challenge first, then answer). It does not distinguish itself from siblings such as game_register or game_disconnect, so an agent must infer that this is the session-start tool rather than the account-creation 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?

Gives concrete usage guidance for the retry path (call again with answer) and for the re-entry path (disconnect, server restart, idle, world transfer → log in again yourself). It gives no exclusions and never mentions game_register as the alternative for a character that does not exist yet.

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?

readOnlyHint=true already tells the agent this is a safe read with no side effects. The description does add genuinely non-obvious behavior — the return payload changes contextually (mine yields a map) — but says nothing about cost (energy/time), whether it works during battle, or failure modes, so it stays at adequate.

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

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

A single dense sentence, front-loaded with the verb and then the payload list. Nothing is padding, though the shorthand phrasing ('Z для входа') is a bit cryptic for an agent that may not know the keybinding convention.

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 parameters, no output schema, and only a read-only annotation, the description carries the burden of describing the return contents — and it does, enumerating all the scene elements including the mine-specific map. Only the absence of cost/availability caveats keeps it short of full completeness.

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

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

The tool takes zero parameters, so the baseline is 4 and there is nothing for the description to compensate for. The schema is fully self-sufficient here.

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

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

States a specific verb ('Осмотреться') and enumerates exactly what the tool reports: cell, buildings, NPCs, nearby players, adjacent cells, plus a map in the mine. That enumeration clearly separates it from siblings like game_status or game_player_info, though it never names a 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 implied (look around to see your surroundings) and the parenthetical 'Z для входа' hints that buildings are entered via a separate action, but it never states when to call this versus game_move, game_status, or game_enter_building, and gives no exclusions.

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

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

The readOnlyHint=true annotation already declares that this is a safe read, so the description does not need to carry the safety profile. It does add value beyond the annotations by disclosing the location precondition (must be inside building type 35, Recruit Base) and the fact that refresh forces a re-fetch of the list. It says nothing about failure modes when outside the building, or about how the returned mission list is ordered or scoped, which limits it to a 3.

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?

Everything sits in one front-loaded sentence with the location parenthetical placed early so the agent can validate the precondition before acting. The clause chain of return contents is dense but scannable. Minor cost: the trailing 'refresh — ...' is glued on with a semicolon rather than given its own sentence, 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?

For a no-param read tool with no output schema, the description does the important work of enumerating what comes back (missions, departure time, prize, recruits, ammo tabs, draft notice), which is exactly what an agent needs in the absence of an output schema. What is missing is the linkage to the sibling tools that act on this state (sign_up, return), so the agent still has to guess how to proceed after reading.

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

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

Schema description coverage is 0% for the single parameter, so the description has to compensate, and it does partially: 'refresh — заново запросить список' explains that the flag forces a fresh list fetch rather than a cached one. That is real meaning beyond the bare boolean type, but it does not say what the default behavior is or what changes in the response when refresh is set, leaving a notable gap for a 0%-coverage schema.

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

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

The description names the resource concretely (the military enlistment office) and enumerates exactly what the agent will get back: missions with departure time, prize and recruit squad, ammo tabs, and the draft notice in the backpack. It is not a bare restatement of the name 'game_military', but it never uses an explicit verb like 'returns/lists', and it does not distinguish itself from the siblings game_military_sign_up and game_military_return.

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 agent is told the office is inside building type 35 (Recruit Base), which is a real precondition for calling it, and the refresh parameter implies repeat/invalidation behavior. However, there is no explicit 'use this when...', no mention of when game_military_sign_up or game_military_return should be used instead, even though they are the obvious alternatives.

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

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

The only annotation is readOnlyHint=false, so the description must carry the behavioral burden. It does add a real consequence – half of the contribution is returned – which is genuine value beyond the annotation. But it omits whether the summons is consumed, whether the action is irreversible, what happens without a summons, and whether any cooldown applies.

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

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

A single short sentence with zero filler, and the action is front-loaded before the parenthetical payoff. Its brevity borders on under-specification, but nothing is redundant.

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

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

For a zero-parameter mutation with no output schema, the essentials are mostly covered: what is done and what is returned. What is missing is prerequisite state (must own a summons), failure behavior, and the resulting state after the call, which an agent would need to chain this with game_military_sign_up or game_status.

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

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

The tool takes zero parameters, so the schema baseline is 4. The description correctly implies a no-argument action, and there are no parameter semantics left to explain.

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 concrete verb and object ('Сдать повестку военкомата' – hand in the military commissariat summons), which is far more specific than the tool name alone. It does not, however, explicitly distinguish itself from the closely related sibling game_military_sign_up, so an agent must infer the direction of the operation (sign up vs. turn in).

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 the tool applies when the player holds a summons and wants to give it back. There is no explicit statement of preconditions (must possess a summons), no mention of when not to use it, and no pointer to game_military or game_military_sign_up as alternatives.

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

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

The only annotation is readOnlyHint=false, so the description carries most of the behavioral burden, and it does: it discloses the 300-copper fee charged on sign-up, that departure happens at the row's scheduled time, and that the player must stay in the building online until then. It does not say what happens if the player leaves or the mission is missed, leaving the consequence side partially opaque.

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

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

Packed into a tight, front-loaded sequence: action and cost first, then parameter sourcing, then timing constraints. Every clause carries facts, though the multi-clause sentence-dense style makes it slightly harder to parse than a short bulleted layout would.

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 mutation with no output schema, the description supplies cost, scheduling behavior, the stay-in-building requirement, and parameter provenance. The remaining omission is the undocumented section value 3 and the outcome of a missed departure, which an agent would need to advise 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 0%, so the description must compensate, and it does for mission_id (source tool) and for section values 1 (Штурмовик) and 2 (Снайпер). However the schema permits section up to maximum 3, and the description never explains what 3 means, leaving a real gap in enum semantics.

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: sign up for a military enlistment office mission, with the cost (300 copper) inline. It also anchors the resource to its sibling by saying mission_id comes from game_military, so the agent can distinguish this from game_military and game_military_return without reading 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?

It tells the agent where mission_id must come from (game_military) and states the operational prerequisite: remain in the building, online, until the departure time on the row. There is no explicit 'do not use if' clause, but the prerequisite and dependency routing cover the practical usage decision.

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?

readOnlyHint=true is consistent with a view/inspect-style tool, so there is no contradiction. The description does add some content-level context beyond the annotation — a room, a step timer, passages, NPC miners, and a surrounding map — which hints at what the read returns. It does not say whether calling it has any side effects on the timer or whether state must be refreshed via game_mine_step.

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

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

It is a single short line with no padding, which is good, but the structure is a colon-separated list of nouns with no verb-first statement of action. Brevity here reflects under-specification rather than disciplined editing.

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

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

With no parameters, no output schema, and two closely related siblings (game_mine_step, game_mine_metro), the description needs to explain the call sequence and what comes back. It gestures at the mine's contents but leaves the flow — inspect, then step, then metro — entirely to inference.

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; the baseline for a parameterless tool is 4. The description correctly implies no input is needed to get the mine view.

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 is a noun fragment — 'Шахта: комната, таймер шага, проходы, NPC-шахтёры, карта вокруг' — with no verb stating what the tool does (open the mine? return its state?). It signals a 'mine' domain but does not separate this tool from siblings game_mine_step and game_mine_metro.

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 at all, and crucially no routing versus game_mine_step (the step action) or game_mine_metro. An agent must guess whether this enters the mine, reads its state, or is a prerequisite for the other two.

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 readOnlyHint=false annotation already signals a state-changing action, and the description adds the meaningful prerequisite that a Red Key is consumed/required. Beyond that it discloses nothing: not where the station takes the player, whether the key is consumed, or what the agent sees on success or failure. For a zero-parameter action tool with no output schema, that leaves notable behavioral 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?

A single short sentence with the action first and the prerequisite attached inline; no filler, nothing buried. It is as compact as a tool name plus one requirement allows.

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?

The definition covers what the tool does and its gating requirement, which is the minimum for a no-argument action. It still omits the outcome of invoking it (destination or effect of the metro station) and any failure behavior, which matters because readOnlyHint=false tells the agent something changes and no output schema documents the result.

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

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

The tool takes no parameters, which is the baseline-4 case. The description correctly implies all inputs (the Red Key) come from game state rather than arguments, consistent with the empty 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 pairs a specific verb ('воспользоваться' / use) with a specific resource ('станцией метро в шахте' / metro station in the mine), so the agent knows this triggers an in-mine metro station rather than generic movement. It does not explicitly distinguish itself from the nearby siblings game_mine, game_mine_step, or game_portal_teleport, which keeps it 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 parenthetical '(нужен Red Key)' gives a concrete prerequisite for use, which is real guidance. However, it never says when this should be chosen over alternatives such as game_mine, game_mine_step, or game_portal_teleport, nor when it would fail or be pointless, 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?

readOnlyHint=false is the only annotation, so the description carries the burden of disclosing behavior, and it does not. It says nothing about whether a step consumes energy/turns, whether movement can fail (blocked passage, insufficient resources), or what the agent gets back. The description does not contradict the mutation annotation, so no contradiction flag.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though so terse that it borders on under-specification rather than achieving a fully self-contained definition.

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 state-changing movement tool with no output schema and minimal annotations, the description should at least say what a successful step yields (a new room description?) and any failure modes. Neither is covered, leaving the agent to discover the result semantics empirically.

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 single parameter is a self-explanatory enum of four compass directions. The phrase 'в соседнюю комнату' (to an adjacent room) implicitly frames direction as a one-step movement vector, which adds a little meaning beyond the enum itself, though no syntax, defaults, or failure semantics are given.

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 ('Шаг' / step) and resource ('по шахте' / through the mine) with a clear scope: moving to an adjacent room. An agent can tell this is a one-tile mine movement. It does not, however, distinguish itself from siblings like game_move or game_mine_metro, which plausibly overlap.

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

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

There is no when-to-use guidance, no prerequisite or exclusion, and no reference to the obvious alternatives (game_move, game_mine, game_mine_metro). The agent must infer from the name alone when this movement tool applies versus the other movement 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?

Annotations only flag readOnlyHint=false, and the description is consistent with a mutation. It adds real behavior beyond annotations: the two-phase flow (rate first, then exchange) and a 0.01 minimum granularity. It does not state what happens on insufficient funds or whether the operation is reversible.

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 and follows with the button analogy and the count caveat. No wasted clauses, though the multiple sub-clauses make it slightly crammed.

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 mutation with no output schema and only a readOnly annotation, the description covers purpose and the preview-then-execute flow. It still leaves the exchange-rate mechanism, failure modes, and result shape 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 0%, so the description must compensate. It explains 'count — how many coins, down to 0.01' and identifies the accepted currencies, but leaves the meaning of count ambiguous (coins spent vs. coins received) and adds no rate mechanics.

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 (exchange/разменять) and precise resources: gold or silver converted into copper. No sibling tool performs currency exchange, so there is no ambiguity with the listed 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?

Implies usage through the analogy to the money-panel 'Разменять' button and the note that a rate is shown before the exchange, but gives no explicit when-to-use/when-not guidance and names no 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?

The only annotation is readOnlyHint=false, so the description carries most of the burden. It does add a real behavioral trait beyond annotations — the slow variant doubles the duration, implying a time cost per move — but it says nothing about whether movement can fail, cost energy/stamina, or be blocked by terrain, which matters for a mutating movement action.

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

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

Two short sentences with no filler, and the core action is front-loaded before the parameter note. The dash-separated 'slow' clause is slightly terse but still readable.

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 movement tool with no output schema and minimal annotations, the description covers the action and the meaning of 'slow'. It leaves out relevant context such as movement cost, failure conditions, and how it relates to faster travel siblings, which an agent would want before choosing 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 0%, so the description must compensate. It does explain 'slow' well (a cautious step taking twice as long), but the required 'direction' parameter is only implied by 'adjacent cell'; the N/NE/... enum is largely self-explanatory, so the gap is moderate rather than critical.

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: 'step into an adjacent cell of the world', which makes clear this is single-tile walking movement. It is not explicitly distinguished from movement-adjacent siblings such as game_portal_escape/game_portal_teleport or game_enter_leave_game_leave_building, but the 'adjacent cell' wording is distinctive enough to separate it from teleport-style 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?

Usage is implied rather than stated: an agent can infer this is the way to move one square, and the 'slow = cautious, takes twice as long' note hints at when the slower option is appropriate. There is no explicit guidance on when to use this versus teleport, enter/leave building, or other movement-adjacent tools, and no 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?

Annotations supply only readOnlyHint=false, so the description carries nearly the whole burden. It confirms a mutation (moving an item) consistent with the annotation, but says nothing about what happens if the destination tab is full, whether item_id must already exist in the backpack, whether the move can fail, or what the response contains.

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

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

A single short sentence with the operation and its scope front-loaded and no wasted words. Its brevity edges toward under-specification, but on pure structure and economy it is clean.

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 mutation tool with no output schema and completely undocumented parameters, one sentence is thin. An agent knows the intent but lacks failure behavior, tab semantics, and prerequisites needed to call it correctly in edge cases.

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 gives only types and bounds. The description partially compensates by identifying the two parameters semantically: item_id is the item and section is the backpack tab in range 0..3. It does not explain what each tab number means (which tab is 0 vs 3), which is the key missing semantic for correct invocation.

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: move an item between backpack tabs (0..3). An agent can grasp the operation immediately. It does not, however, distinguish itself from lookalike siblings such as game_move, game_use_item, or game_equip, so the reader must infer the boundary.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. Usage is only implied by the verb 'move' and the 'backpack tabs' scope; an agent is left to guess when this is preferable to use_item or equip.

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 annotation readOnlyHint=false already signals a mutation; the description adds genuine value by stating the outcome ('вещи падают в рюкзак'), i.e. contents are transferred to the backpack. It does not say whether the pack itself is consumed, what happens if the backpack is full, or what the response contains.

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

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

A single front-loaded sentence with a parenthetical that adds real information about the effect rather than repeating the title. Nothing is padded, though the brevity leaves behavioral gaps that a second short clause could have closed.

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 mutation tool with no output schema and minimal annotations, the description covers the action and the loot destination, which is the minimum an agent needs. It omits consumption semantics, failure modes, and id format, 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 coverage is 0% and item_id has no description in the schema, so the description must compensate; it does partially by clarifying that the id refers to a pack or gift located in the backpack. It never states the expected format (identifier vs. name) or any length/validity constraints beyond the schema's maxLength.

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

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

The description names a specific verb ('Открыть') and resource ('набор или подарок из рюкзака'), so the agent knows exactly what operation is performed. It does not distinguish this from the overlapping sibling game_use_item, which likely also consumes backpack items, so it does not reach 5.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as game_use_item or game_inventory. The phrase 'из рюкзака' only implies that the item must already be in inventory.

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

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

Annotations only declare readOnlyHint=false; the description adds real behavioral context: the payment currency (copper) and the outcome that the purchased perk is placed into the perk panel, making the mutation's side effect predictable. It does not cover failure behavior, but it goes meaningfully beyond the annotation.

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 with the action first and clarifying parentheticals after; nothing is redundant. The nested clauses make it slightly denser than necessary but every clause adds 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 one-parameter purchase mutation with no output schema, it covers cost, required shop state, resulting state, and the follow-up tool for applying the perk. Only failure conditions and the ID source are 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?

With 0% schema description coverage, the description must carry the parameter meaning, and it only implies that the single parameter identifies the perk taken from the open shop window. It does not say how to obtain the item_id or what its format is, leaving a real gap for a 0%-covered parameter.

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

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

The description opens with a specific verb and resource ('Купить ... один перк') and adds scope (for copper, from the open game_perk_shop window). It also names the sibling that handles a nearby-but-different operation (game_use_item), so an agent can distinguish them without opening either schema.

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

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

It states a clear precondition — the shop window must already be open — and routes perk application to game_use_item rather than this tool. It stops short of explicit when-not-to-use cases such as insufficient copper or buying outside a shop session.

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?

readOnlyHint=true already tells the agent this is a safe read, and the description is consistent with that by describing displayed rows rather than an action. It adds the meaningful 'out of combat' precondition and the returned fields, but says nothing about whether results vary by player state or what happens if no perks are available.

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 compact sentence that front-loads the resource and tucks the UI location and returned fields into a parenthetical. Every clause carries information, though the nested parenthetical and quotes make it slightly denser than necessary.

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 parameters, no output schema and read-only annotations, the description carries most of the burden and does explain the row shape (id, price, requirements) plus the out-of-combat restriction. The missing piece is the handoff to game_perk_buy for the actual transaction.

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 no parameter meaning to add beyond the schema. Baseline 4 applies; the description's field list describes output rather than inputs and so neither helps nor harms here.

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

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

States the specific resource (the perk-purchase window / vendor 'Perks' rows) and what it yields (id, price, requirements), which is far more informative than the name game_perk_shop alone. It does not explicitly name the sibling game_perk_buy as the action counterpart, so differentiation is implied 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 parenthetical '«Купить перки» в панели перков, вне боя' gives real context — open this when out of combat from the perk panel — which implies when to use it. However, it never states that this only lists the vendor and that game_perk_buy must be used to actually purchase, leaving the key alternative unspoken.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuinely useful behavior: fixed page size of 8, 0-based paging, and the fact that pricing is not returned here but on the separate purchase call. It does not describe the shape of the returned blueprint data, which matters since there is no output 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?

A single dense sentence with the mode split front-loaded and zero filler. It is slightly compressed, but every clause carries operational meaning (building type, mode branch, page size, price 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?

For a two-parameter read-only tool with no output schema, the description covers the branching behavior, pagination size and origin, and the price-fetch caveat. Remaining gaps, valid category codes and the returned blueprint fields, are modest and largely discoverable through the summary mode.

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 carry both parameters, and it does: page is explicitly 0-based and category acts as a mode switch selecting a per-category listing. It does not say what valid category values look like (single character per the schema), leaving the agent to discover them from the no-category summary call.

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 (public factory, building type 36) and states the two operating modes: a blueprint-category summary or a page of blueprints. It is distinguishable from game_plant_buy/give/make only indirectly, via the closing note that the gold price is fetched on a separate purchase request, so sibling differentiation is implied 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?

It gives a clear conditional rule: call with no category for the category summary, with category for a page. The purchase path is only alluded to as 'a separate request' without naming the sibling tool, so the agent must infer that game_plant_buy is the follow-up.

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 only annotation is readOnlyHint=false, which just confirms mutation; the description usefully adds that gold is spent, a real behavioral trait beyond the annotations. It still omits whether the purchase is repeatable, how count affects cost, and what happens when funds are insufficient — meaningful gaps for a purchase tool.

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

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

A single short sentence with the action front-loaded and the id-source hint tucked into parentheses; no filler. It is efficiently written, though the terseness contributes to the missing param coverage.

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 purchase tool with no annotations beyond readOnlyHint, no output schema, and zero schema description coverage, the definition says far too little. An agent cannot tell what count does, what the result looks like, or why this differs from the other plant and buy 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 0%, so the description carries the full burden, and it only explains draft_id (the blueprint id from the plant page). The second parameter, count (integer, min 1), is never mentioned — no indication whether it buys that many units or whether cost scales with 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 gives a verb ('Купить' / buy) and a resource ('продукт чертежа завода'), plus the currency ('за золото'), so the general action is recoverable. However, 'продукт чертежа' is vague about what is actually acquired, and nothing distinguishes it from nearby siblings such as game_plant_make, game_plant_give, or game_shop_buy.

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 'id чертежа со страницы завода' tells the agent where the required id comes from, which is helpful prerequisite context. There is no statement of when to use this instead of game_plant_make or the various *_buy siblings, and no conditions 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?

Annotations supply only readOnlyHint=false, so the description must carry the behavioral load. It does add real context beyond the annotations: the item is taken from the backpack and converted into resource tickets, making clear it is a consuming exchange rather than a read. It says nothing about failure cases (insufficient count, wrong item type) or whether the deposited amount is all-or-nothing, so the disclosure is partial.

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

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

A single front-loaded sentence with no filler: action, source, destination and reward in order. The only friction is the unexplained shorthand 'b2-s1..8', which reads as internal notation rather than helpful compression.

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 mutation with no output schema, the essential idea (deposit backpack resources for tickets) is conveyed. However, an agent still cannot tell valid item_id formats, what happens on partial or invalid input, or how the ticket payout is computed, which are all real gaps for a consuming trade-in action.

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% — neither item_id nor count is documented in the schema. The description only hints at the item_id domain via the cryptic range notation 'b2-s1..8'; it never explains what item_id accepts nor what count controls beyond the schema's minimum of 1. The description largely fails to compensate for the coverage gap.

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

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

The description names a concrete verb ('Сдать' = deposit/hand over), the resource ('ресурс (b2-s1..8)'), the source ('из рюкзака') and the destination ('на общественный завод'), plus the payout ('в билет ресурсов'). That is a specific verb+resource with a clear outcome. It stops short of differentiating itself from the close siblings game_plant, game_plant_buy and game_plant_make, which keeps it at 4 rather than 5.

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

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

There is no explicit statement of when to use this tool versus game_plant, game_plant_buy or game_plant_make, and no prerequisites are given. Usage is only implied by the phrase 'сдать ... на общественный завод', leaving the agent to infer the situation from game knowledge.

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

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

Annotations only declare readOnlyHint=false, confirming this is a mutation, so the description carries most of the burden. It adds useful behavior beyond the annotations by disclosing the payment source (resource ticket) and the page-context requirement, but says nothing about whether the blueprint is consumed, whether the action is reversible, or what happens on insufficient resources. Useful context, but incomplete for a write operation.

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

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

A single compact sentence that front-loads the action and then the cost condition, with zero padding. It is dense but appropriately sized for a one-parameter 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 one-parameter mutation tool with no output schema, the description covers the action, the input's origin, and the payment mechanism. It still leaves open critical preconditions for a crafting action — required resources, what the blueprint costs, and what the caller receives — which an agent would need to invoke it reliably.

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 0% schema description coverage, the description does compensate: "по чертежу с открытой страницы" tells the agent that draft_id identifies a blueprint visible on the currently open page. That is meaningful semantics beyond the bare string type, though it stops short of describing the expected identifier format or error behavior for a stale/unknown draft.

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 ("Изготовить" — manufacture) plus the resource (an item at the factory, built from a blueprint) and its scope ("с открытой страницы" — from the currently open page). This clearly separates it from siblings like game_plant_buy or game_plant_give, though the phrase about the open page is somewhat ambiguous without more context.

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 note that the blueprint comes "from the open page" implies a precondition (the relevant page must be open) and the mention of payment from a resource ticket hints at a prerequisite cost. However, there is no explicit when-to-use vs. when-not and no direct comparison to the sibling crafting tools (game_plant_buy, game_plant_give), leaving usage largely inferred.

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

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

The readOnlyHint annotation already establishes that this is a non-mutating read operation. The description adds useful behavioral context by saying the content is a live-verified route and combat tactics recorded by previous agents, which implies curated historical guidance. It does not clarify whether the playbook is static or updated over time, nor does it discuss permissions or return characteristics.

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

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

The definition is a single short sentence with no unnecessary wording. The key concept, a playbook of verified routes and combat tactics from previous agents, is front-loaded and easy to parse.

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 parameterless, read-only tool, the description conveys the broad content of the playbook but lacks detail about the return format or scope. With no output schema available, the description should ideally clarify what an agent receives, such as text guidance versus structured route data. It is minimally adequate but 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?

This tool has zero input parameters, so there is no parameter semantics to document. The baseline for a parameterless tool is 4, and the description does not create confusion about 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?

The description identifies the resource as a playbook containing a live-verified route and combat tactics recorded by previous agents. However, it is a noun phrase rather than a clear action, so it does not explicitly state that the tool retrieves or returns this playbook. It also does not differentiate itself from nearby informational siblings such as game_look, game_status, or game_battle_plan.

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 guidance on when to use this tool, such as before combat, when planning a route, or when seeking advice left by prior agents. No alternatives or exclusions are named, so the agent must infer usage from the tool name and description 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's added value is mainly the disclosure of returned content (level, challenge/duel/battle availability), useful given there is no output schema. It says nothing about behavior for a non-existent or offline player, rate limits, or whether the data is a snapshot versus live state.

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

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

A single front-loaded sentence with no filler, and the key 'player card' framing comes first. It loses a point for the muddled tail 'можно ли вызвать на бой, дуэли, бой', where 'бой' is repeated and the distinction between challenge/duel/battle is left ambiguous.

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

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

For a one-parameter read-only lookup with an annotation covering safety and no output schema, the description covers the essentials—what resource, what fields come back. It is still thin on input format for 'login' and on error behavior, which an agent would need before invoking it confidently.

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

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

Schema description coverage is 0% and the single 'login' parameter has no description at all. The phrase 'клик по нику' only loosely implies the identifier is a player nickname, and it never clarifies whether it must be an exact login, whether case matters, or whether it can refer to a player other than the caller—so compensation for the coverage gap is minimal.

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 (player card, the equivalent of clicking a nickname) and enumerates what it exposes: level, whether the player can be challenged, duels, battle. That distinguishes it from siblings like game_status (own state) or game_look (location), though the verb is only implied by the noun phrase rather than written out.

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 'like clicking on a nickname' analogy hints at the use case of inspecting another player, but there is no explicit when-to-use, no indication of what to use instead for one's own profile (game_status), and no prerequisites or failure conditions for unknown logins.

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 readOnlyHint=false already signalling a state-changing action, the description adds the environmental precondition and where the id comes from. It says nothing about cost, cooldown, failure modes, or whether the player is moved immediately, so a mutation tool still has meaningful 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?

A single short sentence with the action front-loaded and the prerequisite in parentheses. Nothing is wasted, though cramming both the location requirement and the id source into parentheses is slightly dense.

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

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

For a one-parameter mutation with no output schema, the description covers the key prerequisite and parameter source. It is still thin on outcome behaviour — what success looks like, whether the id is consumed, or what errors can occur.

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% with one opaque string parameter, so the description must carry the meaning. Saying portal_id is a 'direction id from game_look' is a genuine clarification that the schema lacks, but it does not explain the format or how to extract the id from game_look's output.

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 action (teleport through a portal) and its location context, which distinguishes it from siblings like game_move, game_enter_building, or game_mine_metro. It does not explicitly name an alternative tool, but the verb+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?

It states a precondition — the player must be inside the portal building — and points to game_look as the source of the direction id, which is useful routing. It gives no explicit when-not guidance or comparison against other movement tools such as game_enter_building or game_move.

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

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

Annotations only declare readOnlyHint=false, so the description usefully adds that the action is paid and instant. It does not disclose the cost, whether funds must be available, or prerequisites such as already having a profession or being at the university.

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

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

A single short sentence with the location prefix front-loaded and no wasted wording. It is perhaps too terse, but nothing is redundant.

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

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

With no parameters and no output schema, the definition is structurally simple, but the agent still lacks key operational context: the price, failure conditions, and prerequisites for calling it. The description is adequate but leaves real gaps for a paid mutation.

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 no parameter semantics to explain; the baseline for 0 params applies. Nothing in the description contradicts the empty schema.

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

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

The description names a specific verb and effect ('сразу поднять силу профессии до максимума') plus the location ('Университет') and cost nature ('платно'). It is clearly distinct from siblings like game_university_enroll or game_university_pass, though it does not explicitly say 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?

Usage is implied: use this when you want to max out a profession's strength instantly at the university. There is no explicit when-to-use vs. when-not guidance, e.g., no comparison with normal leveling or game_university.

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

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

Annotations only declare readOnlyHint=false, so the description carries the burden of disclosing mutation behavior: it does not say whether the quest can be re-taken, whether progress/rewards/items are lost, or what the call returns. For a destructive-leaning state change with zero annotation detail, that is a 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?

One short sentence with no filler, and the key constraint is stated up front. Brevity is appropriate, though it edges into under-specification rather than efficiency.

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?

The tool is small (one required param, no output schema), but it is a state-mutating action in a large 70+ tool family, and the definition says nothing about prerequisites, consequences, or the identifier's source. An agent could invoke it but not confidently predict the outcome.

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

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

Schema description coverage is 0% for the single quest_id parameter, and the description does not say where the identifier comes from (presumably game_quests) or its expected form. Nothing is added beyond the bare 'string, maxLength 256' in the schema.

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

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

The description names a specific verb ('Отказаться' — abandon/refuse) and a specific resource ('взятого ... задания' — a taken quest), plus a qualifier that only cancellable quests qualify. An agent can distinguish it from the sibling list/info tools such as game_quests, though 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?

There is no guidance on when to call this rather than e.g. game_quests (to inspect quests first) or to simply keep the quest. The only implicit constraint is that the quest must be already taken and cancellable, which restates the purpose rather than routing between alternatives.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add behavioral context — and it adds very little. It does not say what the journal contains (active vs. completed quests), whether results are paginated or filtered, or what the detailed card includes; it only states that the two modes exist.

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 clauses, front-loaded with the resource and then the modifier, with no filler. It is efficient, though the extreme brevity borders on under-specification rather than optimal conciseness.

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 the description could be adequate, but with no output schema and no parameter documentation in the schema, the agent is left without the contents or shape of the returned journal or card. It also omits any relationship to game_quest_abandon, which is the natural companion action.

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 carry the parameter meaning, and it does explain the effect of supplying quest_id (a detailed quest card instead of the log). However, it gives no format or provenance for the identifier, so an agent cannot tell whether it is a numeric id, a name, or a value obtained elsewhere.

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

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

The description names the resource (quest journal/log) and its two modes: without arguments it returns the log, with quest_id it returns a detailed quest card. That dual-mode statement lets an agent understand the tool without opening the schema. It does not differentiate from the one related sibling, game_quest_abandon, 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?

Usage is only implied: the presence of quest_id selects the detailed view, so an agent can infer when to pass it. There is no explicit guidance on when to use this tool versus game_quest_abandon, and no statement about whether the no-argument listing covers all quests or only active ones.

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

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

Annotations only declare readOnlyHint=false, and the description adds genuinely useful behavior: a two-step challenge round-trip and, critically, that the password is displayed exactly once and must be saved. That one-shot disclosure is the kind of irreversible side effect an agent cannot infer from the schema. It omits failure modes and whether the character is created after the first or second 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?

Four short sentences, front-loaded with the fact that this creates a character, then the procedure, then the password caveat. No filler. The telegraphic phrasing ("Пароль создаёт шлюз") is slightly opaque, which costs a point.

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 three-parameter registration tool with no output schema, the description covers the important unknowns: the two-call flow, the one-time password, and the absence of an email requirement. What remains unstated (return shape, duplicate-name handling, challenge expiry) is secondary but non-trivial.

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 are already documented in the schema, including name format rules and the gender enum. The description adds only the operational role of `answer` (the reply to the check-task), which is a marginal gain over 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?

"Новый персонаж" plus the challenge/password flow makes it clear this is a character-creation (registration) tool, distinct from game_login which it implicitly points to ("сразу после ответа можно входить"). It stops short of naming the sibling explicitly, so it is clear but not maximally differentiated.

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 an actionable procedure: the first call returns a check-task and the agent must call again with `answer`. It also removes a likely false prerequisite by stating email and personal data are not needed. It does not say what to do if the name is taken or how long the challenge remains valid, so it stops short of full when/when-not guidance.

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

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

The annotations only declare readOnlyHint=false, so the mutation nature is already known. The description adds the meaningful precondition 'outside combat', which is real behavioral context not present in structured data. It still omits whether ammo is consumed from inventory, whether the existing magazine is discarded, and what makes the call fail.

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

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

A single short sentence with the core action front-loaded and zero filler. It is clipped to the point of being a fragment, but nothing is wasted or 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 two-parameter mutation tool with no output schema and no documented parameters, the description is too thin. An agent cannot tell how to obtain valid weapon_id/ammo_id values, whether the operation consumes resources, or what happens when the preconditions are not met.

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

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

Schema description coverage is 0% and neither weapon_id nor ammo_id is documented in the schema. The description only obliquely maps to them via the words 'weapon' and 'ammo' (патронами), adding no format, ID-source, or constraint details — for example, whether ammo_id must match the weapon's caliber.

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

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

The description names a specific verb and resource: reload a weapon with ammo, with the additional qualifier 'outside combat' (вне боя). That distinguishes it reasonably well from combat-related siblings like game_battle or game_attack_monsters, though it does not name a direct alternative or reference game_arsenal/game_equip, which are the closest peers.

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?

'Outside combat' (вне боя) is an implied usage condition that tells the agent when this tool is valid, which is more than nothing. However, it never states what to do during combat, which sibling to use for in-battle reloading, or what prerequisite state (weapon equipped, ammo in inventory) must hold before calling.

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

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

Annotations only flag readOnlyHint=false; the description adds a crucial operational fact beyond that: the answer appears exactly once in the call result and is not stored server-side, so it must be captured. It doesn't say what happens on a second call (overwrite? error?) or what permissions are needed, which keeps 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?

One compact sentence with the purpose front-loaded and the one-shot warning appended; nothing is padding. The parenthetical prerequisite slightly interrupts the flow but costs little.

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

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

With no output schema, the description correctly explains the return value is one-shot and must be saved. However, for a tool whose only parameter is an unexplained integer enum-like index, that gap leaves the agent guessing which value to pass.

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

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

Schema description coverage is 0% and the single parameter 'question' is an integer 1-7 whose meaning is entirely opaque — presumably an index into a preset question list, but neither the schema nor the description says which number maps to which question. The description adds no meaning beyond the schema's raw min/max bounds.

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 clear verb+resource ('Задать секретный вопрос') and adds a prerequisite (level 6). It does not name or contrast itself against any sibling tool, but the action is unambiguous on its own.

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

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

It states a concrete precondition for use ('игра требует с 6-го уровня'), which tells the agent when this tool becomes relevant. It gives no exclusions or alternatives, but no close sibling exists that would need disambiguation.

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 readOnlyHint=false annotation already signals this is a write; the description adds the useful behavioral fact that the call is required at first login. However, it says nothing about what gets created, whether the appearance can be changed afterwards, or what happens on a repeat call, which is the main unknown for a one-time setup mutation.

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 purpose sentence with the timing constraint up front, then a terse semicolon-delimited parameter legend. No filler, and the highest-value constraint (mandatory at first login) 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 7-parameter, 6-required mutation with no output schema and only a readOnlyHint annotation, the description covers purpose, timing, and every numeric domain. The remaining gaps — post-call state and re-invocation behavior — are real but secondary for a character-creation step.

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 carries the entire burden — and it delivers concrete value ranges for type, body, bust, head, skin, and hair, including conditional rules (male type 1 → body 1..5, female-only bust, female type 3 → head 1..5). The `male` boolean is covered only implicitly through the gendered wording, but the compensation over an empty schema is substantial.

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 (choose/set) and a specific resource (appearance of a new character), and the parenthetical "обязательно на первом входе" pins down the exact moment it applies. An agent can distinguish it from game_register or game_genetic on purpose alone.

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

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

It states clearly when the tool must be used: mandatorily on the character's first entry, which is actionable timing guidance. It does not name an alternative or say what happens if the agent skips it, 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?

Annotations already declare readOnlyHint=true, so the description does not need to restate safety. It adds useful behavioral context about the two modes, pagination starting at 0, and filter syntax, but does not explain what the summary or item page returns or any access constraints. The 'скупка ресурсов' wording could suggest a transaction, though the separate game_shop_sell_resource tool makes a read-only listing more likely.

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 no filler, and the conditional behavior is front-loaded. The nested parentheses and abbreviations make it slightly harder to parse, but it is appropriately compact for 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 three-parameter read-only tool with no output schema, the description explains how to invoke it but not what the summary or item page contains, nor how it relates to the buy/sell siblings. That leaves gaps for an agent that needs to interpret results or choose among shop 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 coverage is 0%, so the description must carry parameter meaning; it does this well by explaining category as the single-letter category from the summary, page as zero-based, and filter syntax with lvl:a-b, txt, name, and type examples. Some abbreviations remain undefined, but the added meaning is substantial.

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

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

The description names the resource (shop) and defines two modes keyed to the category parameter: no category returns a summary/resource buy-up view, while a category returns an item page. It is specific enough to distinguish the modes, but it does not explicitly contrast itself with game_shop_buy or game_shop_sell_resource, and the phrase 'скупка ресурсов' is ambiguous.

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 clear conditional usage: omit category for summary/resource buy-up; supply a category for the paginated item page. It does not state when to choose sibling tools like game_shop_buy or game_shop_sell_resource, so routing guidance is incomplete.

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

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

Annotations only declare readOnlyHint=false; the description adds an 'opened shop page' prerequisite but does not disclose currency spend, irreversibility, purchase limits, or failure behavior. For a purchase mutation this leaves the central behavioral traits 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?

A single front-loaded sentence with no filler; the parenthetical count note is compact. Slightly cryptic wording ('штучных товаров') costs it a point.

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 mutation with minimal annotations and no output schema, the definition is underspecified: cost/currency, success effect, and count semantics are absent. It gives enough to understand the basic call but not enough to call it safely in all cases.

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 0% schema description coverage, the description at least explains that count is the quantity for piece items and ties item_id to an item on the open shop page. It still leaves item_id format/source and count defaults or edge cases unspecified.

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 ('товар') and scopes it to an opened shop page, which helps separate it from vendor or auction purchase siblings. It does not explicitly name or compare against alternatives, 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?

It implies a prerequisite — the shop page must be open — but gives no explicit when-to-use or when-not guidance and does not mention alternatives such as vendor or auction purchases. The count note is helpful but is not usage routing.

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