Pokemon TCG Pocket Catalog

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 useful behavioral context by listing what metadata is included and prescribing the version-quoting convention, but it does not go further into output shape or any other operational behavior. This is adequate given the 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?

Two sentences with no wasted words: the first fronts the metadata contents, and the second adds a practical usage rule. Every sentence earns its place.

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

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

For a simple zero-parameter metadata tool with no output schema, the description is nearly complete: it names the key fields available and tells the agent how to use the game version responsibly. It could mention response format, but the enumerated contents make the tool's purpose and value clear.

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 burden for the description to carry. The schema has complete coverage by having no properties. The description's content list is the only semantic information needed.

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 tool as providing catalog metadata and enumerates the specific contents (game version, schema version, counts, locales). It is clear about the resource and scope, though it uses a noun phrase ('Catalog metadata') rather than a strong action verb. It is distinguishable from the sibling list tools because it emphasizes aggregate metadata and counts.

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 a concrete usage directive: quote the game version alongside simulation results to keep evidence tied to the data. This tells the agent when catalog_info is relevant. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for a zero-parameter metadata 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?

Annotations already establish readOnlyHint=true, and the description adds meaningful behavioral detail: exact rules checked, the categories of advice returned, and the required ID namespace. This gives the agent a clear picture of what the tool will do without contradicting the 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?

Two focused sentences with no filler. The primary purpose and validation rules come first, followed by the important ID-type constraint. Every sentence adds necessary 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?

The description fully enumerates what the tool checks and what advice it returns, which compensates for the lack of an output schema. Both parameters are documented in the schema, and the read-only annotation covers side effects, so nothing essential is missing for an agent to call this correctly.

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

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

Schema coverage is 100%, so the schema already documents the two parameters. The description adds valuable disambiguation by warning that the tool takes gameplay card ids rather than printing ids, which is critical for correct invocation beyond the schema's brief 'Gameplay card id' label.

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 action ('Check a 20-card Pokémon TCG Pocket deck against the game's rules') with concrete validation criteria and return categories. It clearly differentiates from siblings like simulate_matchup and suggest_deck by framing the tool as a rules/build-advice evaluator, not a simulator or generator. The 'gameplay card ids, not printing ids' note further distinguishes it from catalog/printing-oriented tools.

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

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

The description clearly implies the tool is for validating a deck and getting build advice, so an agent can infer when to call it. It does not explicitly name alternatives or exclusion conditions, but the return categories and validation scope make the intended use obvious across the sibling toolset.

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 signals a safe read, and the description adds meaningful behavioral context: Trainer cards return rules text and subtype instead of attacks, and both printing and gameplay card IDs are accepted. This goes beyond the annotation without contradicting it.

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

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

Three sentences, front-loaded with the core purpose and field list; each sentence earns its place: data content, the Trainer exception, and accepted ID formats. No filler or redundant restatement.

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 enumerates the returned card attributes and calls out the Trainer-card variation, giving an agent a solid picture of what to expect. Minor gaps like invalid-ID behavior are acceptable for a read-only lookup tool.

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

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

Schema description coverage is 100%, and the schema already documents both parameters with the same ID examples and locale default. The description reinforces the ID forms but does not add new parameter-level meaning, so the baseline of 3 is appropriate.

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

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

States a specific action ('Get') and a specific resource ('one Pokémon TCG Pocket card's available catalog data') with an enumerated field list. The singular-card scope clearly distinguishes it from list/search siblings, and the two accepted ID formats are explicitly given.

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

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

The description implies the usage case—fetch card data when you already have an ID—by spelling out both accepted ID formats. However, it offers no explicit when-not guidance or pointer to search_cards/list_printings for lookup without an ID, so routing guidance is mostly implicit.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful context about the contents being translation locales, but does not disclose return shape, ordering, or other behavioral details. With the annotation covering safety, this is adequate but not rich.

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

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

Two sentences, front-loaded with the core purpose and followed by the key usage implication. Every sentence earns its place with no redundancy or filler.

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

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

For a zero-parameter, read-only list tool, the description fully covers what is returned and why it matters. It omits minor details like formatting of locale codes, but those are not necessary 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?

The tool has zero parameters, so the baseline is 4. The schema is empty and provides no ambiguity, and the description adds meaningful context about how the returned values are consumed by other tools.

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

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

The description uses a specific verb ('List') and a clear resource ('every locale code the catalog has translations for'). It clearly distinguishes this from sibling tools like list_sets and list_packs by positioning it as the locale source feeding those tools.

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

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

The description gives clear downstream guidance: pass a returned locale code as the 'locale' parameter to other tools for localized names. It does not explicitly state when not to use it, but no exclusion is needed given the tool's simple helper role.

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 already declare readOnlyHint=true, so the safe-read behavior is covered. The description adds useful detail about what is returned and why pack ids matter, but it does not disclose behaviors like ordering, pagination, or localization defaults beyond what the schema already provides.

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

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

The description is two sentences with no filler. The core action and output fields are front-loaded, and the clarifying statement about pack ids earns its place by adding practical use 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 simple read-only list tool with zero required parameters and a fully documented schema, the description is complete. It states what will be listed, the fields returned, and why the result matters. No output schema exists, but the description sufficiently covers the return value shape.

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?

Parameter schema coverage is 100%: the only parameter, locale, is already described with its default value. The description's mention of 'localized name' aligns with the locale parameter but adds no new semantic detail beyond what the input schema provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('List'), a clear resource ('every Pokémon TCG Pocket booster pack'), and names the exact fields returned (id, parent set id, localized name). It also clarifies the distinction between packs and printings with 'Pack ids identify where a printing can be pulled,' which helps separate it from siblings like list_sets and list_printings.

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

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

The description makes the tool's scope unambiguous: list every pack, with no filtering. The closing sentence gives practical context for when a pack id is needed. It does not explicitly name alternative tools or state when not to use it, but the context is clear enough for an agent to select it correctly.

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 and openWorldHint annotations, the description discloses that the tool returns all printings rather than only the first, lists the returned fields, and explains the two accepted ID formats. It adds meaningful context without contradicting the 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?

Two sentences carry the core scope, returned fields, ID flexibility, and sibling differentiation with no filler. The most important information is front-loaded and every clause earns its place.

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

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

With no output schema, the description carries return-value disclosure, and it lists the specific fields returned. Combined with the annotations and simple parameter schema, an agent has enough context to decide when to invoke it and how to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the accepted ID formats with examples, but it does not add semantic information beyond what the schema already provides for either 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 states a specific verb and resource: list every printing of one card across all sets. It enumerates the returned fields and explicitly contrasts itself with get_card, so an agent can distinguish it from the closest sibling without inspecting schemas.

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

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

The description explicitly names get_card as the alternative and gives the selection condition: use this when the question involves reprints, alt arts, or pull sources. This is direct routing guidance rather than implied usage.

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 value by specifying the result includes every set and the exact output fields, but it doesn't disclose ordering, pagination, or other behavioral details. This is adequate but not rich.

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

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

Two short sentences with no redundancy: the first states the tool's purpose and output, the second states the usage sequence. The description is front-loaded and every sentence earns its place.

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

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

For a simple read-only list tool with no required parameters and no output schema, the description is complete: it names the output fields and connects the tool to search_cards. Minor gaps like locale behavior are already covered by the schema.

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

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

The input schema already documents the only parameter (locale) with a description and default value (100% coverage). The tool description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('List') and resource ('every Pokémon TCG Pocket set') and explicitly names the output fields ('id and localized name'). It clearly distinguishes itself from siblings like list_packs and list_printings by naming the resource type.

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

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

The description provides a concrete usage instruction: 'Use the ids to filter search_cards by set.' This tells the agent how to chain the tool with a sibling. It doesn't explicitly discuss when not to use it, but the resource specificity makes the intended context clear.

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 and openWorldHint; the description adds concrete output behavior: returns up to 20 summarized cards plus total match count. It does not detail ordering or matching semantics, but read-only safety is already covered by 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?

Two sentences with no filler: the first packs the search subject and all filter dimensions, the second states the result cap and total count. Information density is high and the structure is 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 read-only tool with 13 optional parameters and no output schema, the description covers search keys, filter dimensions, and output shape. Pagination and locale details are handled by the schema. Minor omissions like result ordering do not materially hurt selection or 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 85%, so the schema carries most parameter meaning. The description lists filter categories but largely paraphrases existing schema descriptions, such as query accepting name, attack, ability, artist, or id. It adds little beyond a useful capability overview.

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

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

The description uses a specific verb and resource: 'Search the Pokémon TCG Pocket card catalog' and enumerates both search keys and filters. It clearly distinguishes itself from siblings like get_card (single card retrieval) and list_sets (set listing).

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

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

The description gives clear context: this is for searching and filtering the catalog, returning summarized matches. It does not explicitly state when to prefer get_card or list_sets, but its search+filter+summary nature makes the intended use reasonably obvious.

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 already mark this as read-only and not open-world, and the description adds meaningful behavioral context: the simulation is deterministic, uses heuristic AI, returns failure counts, and is explicitly not a proxy for human play. This goes well beyond the annotation hints and helps the agent set expectations about results.

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

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

The description is three tight sentences with no fluff: it states the action, the output, and the key caveat. The purpose and distinguishing information are front-loaded, and every sentence contributes necessary guidance.

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, but the description explicitly enumerates the return contents, which is essential. The parameters are fully described by the schema, and the description adds the key context about determinism and AI-policy measurement. It could go slightly deeper on what 'failures' means or how legality is enforced, but it is sufficient for a capable agent.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds the notion of 'legal 20-card' decks and the deterministic simulation context, but it does not add substantial meaning to individual parameters like seed, games, or locale beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Run'), names the exact resource ('Battle Lab rules engine'), and clearly states the inputs ('two legal 20-card Pokémon TCG Pocket decks') and the outputs ('wins, draws, failures, average turns/actions, and a short sample game log'). It also distinguishes itself by clarifying that it measures the built-in AI policy, not human skill or competitive win probability.

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 a clear 'when-not' by explicitly stating that it measures AI policy, not human skill or competitive win probability, which prevents misuse for win-rate prediction. However, it does not explicitly name sibling alternatives like evaluate_deck or trial_deck, so the agent must infer the exact tool-selection boundary from context.

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, and the description adds value by disclosing the exact return payload (archetype, why it works, limitations, full list with copy counts) and the special Trainer-target behavior with an 'explicit effect-data limitation.' No contradiction with 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?

Three short sentences front-load the core purpose, then add output expectations and the one input caveat. Every sentence earns its place and there is no repetition of schema metadata.

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 fully covers return values (archetype, rationale, limitations, full card list with counts) and the edge case of Trainer cards. Combined with 100% schema coverage and readOnlyHint annotation, the agent has enough to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics by stating that query and cardId are alternatives ('either ... or'), clarifying how the agent should populate them; it also explains the practical effect of choosing a Trainer target, which the schema alone does not convey.

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: 'Build a complete, legal 20-card Pokémon TCG Pocket deck around a chosen card.' It enumerates concrete outputs (archetype, rationale, limitations, card list with counts) and distinguishes itself from siblings like evaluate_deck and simulate_matchup by focusing on deck construction around a desired card.

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 clearly states the invocation context ('around a chosen card') and gives input guidance ('Give either a card name to search for or a gameplay card id'). It does not explicitly name alternatives or when-not-to-use conditions, but the 'chosen card' framing is clear enough to route an agent away from evaluation/simulation 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?

Annotations already declare readOnlyHint=true, and the description is consistent with that by describing simulation rather than mutation. It adds useful behavioral context that annotations don't provide: what metrics get computed, that it samples opening hands, and that it runs mirror self-play. The seed-related reproducibility is left to the schema, so a small gap remains.

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 dense sentences with no filler: the first describes the core behavior and outputs, the second gives routing guidance, and the third states the critical input id rule. It is front-loaded with the verb and resource and every sentence earns its place.

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

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

The tool has no output schema, so the description's enumeration of result metrics (Basics per opener, Trainer density, card show rates, closing speed, first-player bias) tells an agent what to expect. It also covers legality ('legal 20-card deck') and the single-deck vs. two-deck boundary. A minor gap is that the exact return structure is not specified, but the listed metrics are sufficient for correct selection and 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 100%, so the baseline is 3. The description adds value beyond the schema by clarifying that gameplay card ids are required, not printing ids, which maps directly to the gameplayCardId parameter. It also reinforces the '20-card' constraint from the deck schema, helping agents validate inputs before calling.

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: 'Solo-trial one legal 20-card Pokémon TCG Pocket deck,' then enumerates concrete analyses (opening-hand consistency, mirror self-play, closing speed, first-player bias). It also names a sibling tool to differentiate from, making the purpose unmistakable.

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

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

The description explicitly states when to use this tool versus its alternative: 'Use this to tune a single deck; use simulate_matchup to compare two decks.' It also provides a crucial prerequisite: 'Takes gameplay card ids, not printing ids,' preventing a likely invocation error.

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