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

No annotations are provided, so the description carries the full disclosure burden. It communicates that the action backs out of an overlay (a state change), but says nothing about consequences such as whether pending selections are discarded or whether the turn/game state is affected. Output schema exists, so return values are covered elsewhere.

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 no filler. Nothing wasted.

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

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

For a simple zero-parameter action with an output schema, the essentials are present. However, in a game context where cancel competes closely with confirm, proceed, and leave, the description leaves the agent to infer whether cancel aborts a pending decision or merely closes UI.

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 applies. No misleading or missing parameter information.

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 (cancel) and its target (the current overlay), which is enough to separate it from siblings like confirm, proceed, and choose. It stops short of explicitly naming those siblings or describing the overlay concept, so it is clear but not maximally differentiating.

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 current overlay" implies a situational precondition, so usage is implied rather than stated. There is no explicit contrast with confirm, proceed, or leave, which are the obvious alternatives an agent would weigh when an overlay is open.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about what happens on an out-of-range index, whether the choice is committed immediately or irreversibly, or what the tool returns. It only conveys the one detail that indexing is 0-based, which is helpful but far from complete for a state-mutating selection tool.

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

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

A single, front-loaded sentence with zero filler; the parenthetical examples are compact and useful. The phrasing 'choice_list/screen option' is slightly loose but does not cost readability.

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?

An output schema exists, so return values need not be described, and the core act of choosing by index is covered. However, with no annotations the description should still address irreversibility and sequencing relative to get_decision_pack/get_game_state, which it omits.

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 labels the parameter as an unadorned integer. The description adds the critical detail that indexing starts at 0 and indicates the kinds of option lists it addresses, which is meaningful compensation, but it stops short of saying how the index maps to entries in choice_list.

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 ('Pick') and resource ('choice_list/screen option') with a clear key detail (0-based index) and concrete contexts (events, map nodes, Neow, card rewards). It is distinguishable from most siblings, though it does not explicitly contrast with 'confirm'/'cancel', which likely operate on a different selection mechanism.

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

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

No explicit when-to-use or when-not-to-use guidance, and no alternatives are named despite several siblings (confirm, cancel, proceed, play_card) that plausibly overlap. The enumerated contexts (events, map nodes, Neow, card rewards) only imply when it applies.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does not say whether this mutates game state, whether it is reversible, what happens if no selection exists, or what happens after confirmation. 'Confirm' implies a state-changing commit, but that is inference, not disclosure.

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 wasted framing, and the core action is front-loaded. It is terse to the point of under-specification rather than bloated, which is the better failure mode.

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?

An output schema exists, so return values need not be explained, and zero parameters means the schema is trivially complete. What is missing is behavioral and situational context: in a sibling set containing 'choose', 'proceed', 'cancel', and 'run_turn', the agent gets no signal on how this call interacts with or differs from them.

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 clarify beyond the schema. Baseline for a parameterless tool applies; the parenthetical about grid contexts is a minor extra hint.

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 verb ('Confirm') and an object ('the current selection') with a parenthetical hint about grid contexts, so the basic action is identifiable. However, it does not distinguish itself from close siblings like 'choose', 'proceed', or 'run_turn', which plausibly overlap with committing a selection. Reads as adequate but under-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?

No guidance on when to confirm versus 'choose', 'proceed', or 'cancel' is provided. The only contextual cue is the vague 'grid confirm etc.', which does not tell an agent which state or precondition makes this tool the right call over its siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state what ending a turn triggers (opponent actions, state changes), whether it is reversible, or any sequencing constraints, leaving the mutation's consequences 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?

A single front-loaded sentence with no filler; it is appropriately sized for the action. It errs toward under-specification rather than verbosity, which is not a conciseness failure.

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 output schema covers return values and there are no parameters to document, so the surface is small. Still, a state-mutating tool with no annotations and no output/params needs the description to explain consequences, which it omits.

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 for a no-argument 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 ('End') and resource ('current combat turn'), so the action is unambiguous. However, it offers no differentiation from siblings like run_turn or proceed, which an agent might reasonably confuse with ending a turn.

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 end a turn versus calling run_turn, proceed, or confirm. The agent must infer the trigger condition 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?

With no annotations, the description carries the full behavioral burden and does so well: it discloses the aggregation method (median per effect), the confidence band written (0.65-0.85, prov="observed"), and the non-destructive rule that higher-confidence dll/static entries are never overwritten, with disagreements stashed in the entry's "obs" field. It still omits whether the accumulated buffer is cleared after flushing and whether repeated calls are idempotent — the main remaining gap for a mutation tool.

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

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

The action and its destination are front-loaded in the first sentence, and each following clause adds non-redundant information about aggregation, provenance, and overwrite behavior. It is dense with domain jargon (prov, dll/static) but no sentence is wasted.

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

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

An output schema exists, so return values need not be described, and there are no parameters to document. The description covers the aggregation and persistence semantics thoroughly; the only missing piece is lifecycle detail such as whether flushing drains the observation buffer or requires an active game context.

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 and no schema gap to compensate for. Baseline 4 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 states a specific verb and target ('Write accumulated card-play observations into card_kb1.json') and explicitly separates this tool from the siblings that generate the data ('play_card / run_turn record before/after state diffs; this tool aggregates them'). An agent can distinguish it from play_card/run_turn without opening any 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 establishes clear context: observations are accumulated by play_card/run_turn and this tool persists them, which tells the agent when the tool is relevant. It stops short of an explicit trigger ('call after N turns') or any when-not condition, so it is strong context rather than full routing guidance.

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

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

No annotations are present, so the description carries the full burden. It does disclose meaningful traits — no free-text fields, cards keyed by id, advisor output shape, and the separation of mod resources (toughness never mixed into HP lethal math) — but much of this restates what the output schema covers, and it says nothing about side effects, safety, or cost of calling.

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

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

Front-loaded: the core statement comes first, then structured detail. It is reasonably tight, though the closing mod-mechanics example is quite domain-specific and borders on detail that could live elsewhere.

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

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

For a zero-parameter tool with a full output schema, the definition gives ample orientation about what the pack contains. Its only real gap is guidance on when this feed is preferred over the other read tools, which the description does not address.

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 no-arg 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 specific verb and resource ("Get a compact decision pack") and pins down its role as "the primary LLM feed." It characterizes content precisely (structured effects plus advisor output), but never names or contrasts the closest sibling, get_game_state, leaving the agent to infer why one would be chosen over the other.

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: "primary LLM feed" suggests this is the default read, but there is no explicit when-to-use, when-not-to-use, or comparison to get_game_state / run_turn / proceed. The reader must infer the routing.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses a data-shaping behavior beyond the schema — raw Japanese `name` fields are stripped while `id` remains the stable key — but says nothing about whether the call mutates state, its cost, or read-only guarantees.

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

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

Front-loads the core purpose in the first clause, then a single sentence of detail on sanitization, with an example id. Efficient and well-ordered, with only mild redundancy between the parenthetical and the following sentence.

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

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

An output schema exists, so return structure needn't be spelled out, and the description adds the one thing the schema can't convey: that name text is intentionally absent so the agent doesn't treat it as a gap. For a zero-parameter read tool this is nearly sufficient, lacking only usage context.

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. The description correctly spends its words on output semantics instead.

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

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

States a specific verb+resource ('Get the current game state') and adds scope via the sanitization note. It does not differentiate itself from the other 'get'-style sibling (get_decision_pack), so it stops short of a 5.

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

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

The description is entirely about output content and never says when to reach for this tool versus get_decision_pack, end_turn, proceed, or the other siblings. An agent must infer that reading state precedes decisions, but no condition or alternative is named.

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

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

With no annotations, the description carries the behavioral burden and does disclose one meaningful constraint (cannot be invoked during combat), which is more than nothing. It does not say what happens to the character/state after leaving or whether the action is reversible, leaving a gap for a state-changing tool. Return values are covered by the output schema, so that omission is acceptable.

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

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

A single short sentence containing the action and its constraint, with the action front-loaded and 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 zero-parameter, low-complexity tool whose return shape is documented by an output schema, purpose plus the out-of-combat constraint covers what an agent needs to call it. The only real gap is the absence of any post-action state description, which is minor at this complexity level.

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 per the baseline there is nothing for the description to disambiguate. The schema is trivially complete and the description adds no parameter noise.

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 ('Leave') and a concrete resource ('the current room/shop'), so the action is unambiguous. It does not explicitly contrast itself with navigation-adjacent siblings like proceed or cancel, but the verb+resource pairing is distinctive enough that confusion is unlikely.

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 an explicit precondition/exclusion – 'out of combat only' – which tells the agent when this call is legal. It stops short of naming what to use instead when in combat, so the when-not is stated but alternatives are not.

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

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

With no annotations, the description carries the full burden. It discloses one genuinely useful behavior – 're-resolves the hand index' – warning that previously read indices may be stale. However, it says nothing about energy cost, what happens if the card is unplayable or the target index is out of range, or whether the play 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?

Front-loaded with the core action, then a compact Args block that mirrors the two parameters without padding. The parenthetical about hand-index re-resolution is the only non-obvious content and it earns its place; the rest is terse and 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?

An output schema exists, so return values need no explanation, and both parameters are fully documented despite zero schema coverage. For an unannotated mutation tool the remaining gap is failure/validity behavior (illegal card, insufficient energy, invalid target), which leaves it just short of complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it names the source of `card_id` (the `id` field from state/decision_pack), gives a concrete example ('Strike_R'), and explains `target_index` as a 0-based enemy index with an explicit omit condition. Only valid ranges and error behavior for bad indices are left unstated.

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 ('Play a card by its `id` from hand') and clarifies the index is re-resolved, so the agent knows exactly what the operation does. It does not, however, distinguish itself from ambiguous siblings like `choose`, `confirm`, or `send_command`, which could plausibly be routes to the same action.

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 infers it should call this when it wants to play a card, and the note about omitting `target_index` for non-targeted cards is a useful conditional. There is no explicit when-to-use versus `choose`/`send_command`, and no prerequisite guidance such as needing a pending 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: it does not say whether pressing advances game state, whether it is idempotent, what happens if no proceed button is present, or whether it can fail. 'Generic' is the only behavioral hint.

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 repetition. It is arguably too terse to earn a 5, since the size reflects under-specification rather than efficient completeness.

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 zero parameters and an output schema present, the description does not need to explain return values, so the remaining burden is small. However, for a state-mutating UI action with no annotations, it should at least say when the button exists and what the click effect is; that gap keeps it at minimally adequate.

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

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

The tool takes zero parameters and the empty schema exhausts the structured surface, so per the rubric the baseline is 4. There is no parameter semantics the description could usefully add.

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 action ('press') applied to a specific UI element ('the generic proceed/continue button'). The word 'generic' hints it is distinct from the more specific siblings (confirm, choose, play_card), but it never explicitly says how it differs from 'confirm' or 'end_turn'.

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

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

The description gives no when-to-use guidance and no exclusions. With siblings like confirm, choose, end_turn and run_turn in the same namespace, an agent has no stated rule for picking 'proceed' over those 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?

With no annotations, the description carries the full burden and discloses real behavioral detail: it builds a decision pack, executes advice.plan through Communication Mod, re-resolves hand indices by card id, and returns the pack plus execution log. It also flags a co-op latency quirk. It stops short of stating prerequisites (e.g., advisor availability) or that game state is mutated.

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

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

The purpose is front-loaded in the first sentence, followed by mechanism and a timing caveat. Three short sentences with little waste; the parenthetical is informative rather than filler.

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

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

An output schema exists, so explaining return values is not required, and the description covers the build-execute-return mechanism well. But for an autonomous mutating tool with no annotations and an unexplained parameter, it omits prerequisites and parameter guidance that an agent would need.

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 one parameter (sleep) with 0% schema description coverage, and the description never mentions it. Since coverage is below 50%, the description was expected to compensate, and it does not, leaving the parameter's meaning and units entirely opaque.

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

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

The description states a specific verb and scope: 'Autonomously play one combat turn via the advisor.' This distinguishes it from manual siblings like play_card or end_turn by emphasizing a whole autonomous turn. However, it never explicitly names those alternatives, so differentiation is inferred rather than stated.

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

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

There is no when-to-use guidance and no comparison against relevant siblings such as get_decision_pack plus send_command, or end_turn. The co-op timing note is behavioral context, not a usage rule.

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

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

No annotations, so the description carries the full burden. It discloses the raw/format-sensitive nature of the input and the 1-based/0-based index conventions, which is useful behavior context, but says nothing about what happens on malformed commands, error responses, or side effects of game-state-mutating commands like PLAY or POTION.

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 and the command grammar earns its space since the schema documents nothing. Only quibble is that the 'prefer dedicated tools' selection cue would be better placed before the long grammar, since it affects whether the agent uses this tool at all.

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?

An output schema exists, so return values need no explanation, and the input contract is fully specified. The remaining gap is failure behavior for invalid or out-of-range command lines, which an agent calling a raw escape-hatch command would benefit from knowing.

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% for the single 'line' parameter, so the description must carry everything — and it does: a full grammar for each command plus the critical indexing conventions (PLAY hand 1-based, enemy 0-based). This is exactly the compensating detail the schema omits.

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 ('Send a raw Communication Mod command line') and immediately differentiates itself from siblings by naming play_card/end_turn/choose/proceed as preferred alternatives. The enumerated command grammar makes the scope unambiguous, though 'Communication Mod' is jargon an agent must already know.

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

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

Explicitly tells the agent to prefer dedicated tools and why ('easier to get right'), which is real routing guidance. It stops short of saying when this tool IS the right choice (e.g., for POTION, KEY, CLICK, WAIT, START which have no dedicated sibling), leaving that to inference from the command list.

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