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

With no annotations, the description carries the burden and does well: it enumerates the outputs (resource/influence totals, tech skips, wormholes, anomalies, legendary planets, Mecatol path, ranking) and clarifies this is an analysis operation. It lacks execution details like cost or input validation behavior, so it falls just short of 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?

Three tight sentences, front-loaded with the action, then input structure, then outputs. Every sentence adds information with no redundancy.

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 the description correctly enumerates return fields, and the single parameter's nested structure is fully explained via the index legend. Nothing an agent needs to invoke it correctly 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 is 3, but the description adds real meaning beyond the schema by mapping each array index to a board position (0=home-left through 4=mecatol-gate), which the schema does not document.

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 ('Analyze and compare Milty Draft slices') with a precise scope. It is functionally distinct from all siblings (factions, tech, planets, etc.), though it never names or contrasts an alternative, so it stops short of the 5 tier.

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 by the functional description; there is no explicit 'use this when' statement, no prerequisites, and no named alternative. An agent can infer you call it to evaluate draft slices, but nothing is stated directly.

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 identifies the target of the mutation, but says nothing about reversibility, whether clearing an empty context errors, or any side effects on related state — significant gaps for a destructive-style 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 front-loaded sentence with no filler, appropriate to a zero-argument tool. It is efficient, though slightly terse for a state-mutating operation.

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 no-input mutation tool with no output schema the description covers the minimum viable ground, but the absence of any behavioral context (reversibility, error conditions, relationship to set_game_context) leaves it only 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 is consistent with that, so there is no parameter semantics to explain. Baseline 4 applies since nothing needs compensating.

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 (Clear) and resource (current game setup context), so an agent can distinguish it from the get_/set_ variants in the sibling list. It does not explicitly name the alternative siblings, 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?

No when-to-use guidance appears beyond the implied meaning of 'clear'. It never says whether to call this before setup_game, when a stale context exists, or how it relates to set_game_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?

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing: no mention of error behavior for unknown IDs, how expansions affect the result, or return shape. 'Get' implies a read, but that is the extent of 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?

A single front-loaded sentence with zero waste. Every word earns its place and the resource and lookup key are stated immediately.

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 single-record lookup with 100% schema coverage and no output schema to explain, the description is adequate. It omits only minor context such as unknown-ID behavior, which is tolerable 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?

Schema description coverage is 100%, so both card_id and the expansions default/enum handling are already documented in the schema. The description adds no parameter meaning beyond what the schema provides, making the baseline 3 correct.

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 specific TI4 action card by ID'), and the phrase 'specific...by ID' distinguishes single-item retrieval from the list_action_cards sibling. It does not name the sibling explicitly, so it stops short of clear 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?

No when-to-use guidance or alternative mentioned. The only signal is the implied 'use when you have an ID,' with no exclusions or direction to list_action_cards for discovery.

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 disclosure burden, yet it only implies a read lookup. It says nothing about error behavior for an unknown ID, whether expansions filter or only widen results, or the shape of the returned card.

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 efficient, though arguably under-specified rather than maximally concise.

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-item lookup with 100% schema coverage and no output schema, the description covers the essentials. It omits only the expansions interaction and error behavior for a missing ID, which are minor 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 coverage is 100%, so both parameters (agenda_id, expansions) are already documented in the schema, including the expansion fallback default. The description's 'by ID' adds only marginal framing beyond that, matching the baseline 3 when the schema does the work.

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 ('Get') and resource ('TI4 agenda card') and scopes it to a single item via 'by ID', which implicitly separates it from list_agendas. It's clear but never explicitly names or contrasts with the sibling list 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?

No when-to-use guidance beyond the implied 'you need an ID' reading. It never points to list_agendas for discovery or search for lookup by name, leaving the agent to infer the routing condition.

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 disclosure burden. The 'Get' verb implies a non-mutating lookup, which is reasonable, but the description says nothing about behavior when faction_id is unknown or how the expansions parameter changes the returned data. Adequate for a simple read, but far from 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?

A single sentence with the verb and resource front-loaded and a compact enumeration of return contents. Nothing is padded or 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 output schema, the description usefully previews the returned fields, which is the main thing the agent needs. It falls short only on how expansion context shapes results and on failure behavior for an invalid faction_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 100%, so both faction_id and expansions are already fully documented in the schema, including the full enum list. The description adds no parameter meaning beyond what the schema supplies, which is the baseline-3 case.

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 (Get) and resource (TI4 faction) and enumerates the payload the caller receives (abilities, starting tech, units, leaders, promissory note). It does not differentiate itself from the nearby list_factions or get_faction_guide siblings, so an agent must infer the boundary.

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

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

No when-to-use guidance and no mention of alternatives. The presence of list_factions and get_faction_guide as siblings makes the omission notable, because nothing tells the agent to call this one only when it already has a faction_id.

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 does disclose that content is drawn from competitive community sources, which signals the material is subjective/opinionated rather than canonical rules text. However, it says nothing about read-only nature, behavior for unknown faction IDs, or result completeness.

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 that opens with the core action and then itemizes the payload. Slightly long but free of filler and no wasted clauses.

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?

Though there is no output schema and no annotations, the description compensates by enumerating the returned fields (strengths, weaknesses, tips, tech paths), so an agent knows what to expect. Minor gaps remain around unknown-faction behavior and whether the guide is static or versioned.

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 there is only one parameter, whose format is documented in the schema with examples. The description adds nothing about the faction_id beyond what the schema already states, so the baseline 3 applies.

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

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

States a specific verb (get) and resource (strategy guide for a TI4 faction) and enumerates the content returned: strengths, weaknesses, tips, tech paths. This separates it from data-oriented siblings like get_faction and list_factions, though it never explicitly names them as alternatives.

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 this is for retrieving strategy guidance for a single faction. There is no explicit when-to-use, no when-not-to-use, and no routing away from get_faction or list_faction_guides.

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 and no output schema, the description carries the full disclosure burden, and it does add real information: it names the four categories of data returned. The remaining gap is failure/edge behavior — what is returned or thrown when no game context exists is never addressed.

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, front-loaded with the verb and resource, with the parenthetical payload list as the only elaboration. Nothing is padded or repeated.

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 field enumeration is what an agent most needs, and it is present. The definition would be complete if it noted the empty/no-game case, which is the one realistic ambiguity.

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 a closed empty object, so there is no parameter semantics to document. The baseline for a parameterless tool is 4; the description correctly adds no redundant parameter talk.

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

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

The description states a specific verb (Get) and resource (current game setup context), then enumerates the concrete payload (expansions, player count, faction assignments, speaker). That is far more informative than the bare name. It stops short of naming the set_game_context/clear_game_context siblings to route the agent, so it does not quite reach the top band.

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 statements are given. Usage is only implied: an agent infers it should call this to learn the current game state before acting. It never mentions the read/write/clear alternatives (set_game_context, clear_game_context) or any prerequisite such as a game already being set 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?

No annotations are provided, so the description carries the full behavioral burden. It doesn't say whether this is read-only (though the word 'Get' strongly implies it), what happens with an unknown ID, whether the return is localized, or whether expansions affect resolution.

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 efficient sentence with no waste, front-loading the verb and resource.

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?

Adequate for a simple two-param lookup with full schema coverage and no output schema, but with no annotations it should at least clarify read-only behavior and ID acquisition from list_objectives.

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 baseline is 3. The description adds only that the lookup is by ID; it does not elaborate on objective_id syntax, expansion interplay, or the omitted-expansions-default behavior beyond what the schema already documents.

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?

Clear verb+resource: 'Get a specific TI4 objective by ID.' It distinguishes this lookup from its obvious sibling list_objectives, though it doesn't name the alternative explicitly. It is specific enough for an agent to know what the tool retrieves.

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 when-to-use or when-not-to-use guidance, and no exclusion of alternatives. The description does not state that list_objectives should be used to discover IDs before calling this lookup.

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

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

No annotations are provided, so the description carries the full burden; it implies a safe read via 'Get detailed information,' which is consistent behavior. However, it discloses nothing about return payload, whether expansion-scoped results differ, or error behavior for unknown IDs.

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, well sized for a simple lookup tool. It is arguably too terse to earn full marks, but nothing in it 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?

A two-parameter read tool with full schema coverage and no output schema needs only modest description support, and this covers the core purpose. Still, 'detailed information' is unhelpfully vague — it doesn't hint at planet traits (resources, influence, tech specialty, legendary status) or how the expansions parameter changes 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?

Schema description coverage is 100%: both planet_id (with examples) and the expansions list with its default behavior are fully documented in the schema. The description adds no format, casing, or expansion-resolution detail beyond 'by ID', so the 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?

States a specific verb and resource ('Get detailed information about a TI4 planet') and specifies the lookup key ('by ID'), which is enough to distinguish it from list_planets. It does not, however, explicitly name its closest sibling (e.g., get_system) to clarify the boundary.

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

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

Usage is only implied by the name: an agent can infer this is the single-planet detail lookup versus list_planets for enumeration. There is no explicit when-to-use/when-not guidance, no mention of prerequisites, and no routing to get_system despite the sibling set containing overlapping concepts.

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, yet it discloses nothing about behavior: not that this is a read-only lookup, what an invalid relic_id yields, or how omitting expansions resolves (the schema hints at game-context default but the description does not). Return format is also unexplained with 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 front-loaded sentence with zero filler. Nothing is redundant and the identifying constraint (by ID) is stated immediately.

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

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

For a simple two-parameter lookup with full schema coverage, the description is minimally sufficient, but with no annotations and no output schema it leaves the return shape and error behavior unaddressed. It is adequate rather than 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%, so both relic_id and expansions are fully documented in the schema, including the expansion enum options and the base-game default. The description adds no meaning beyond that, 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?

States a specific verb (get) and resource (TI4 relic) scoped to a single item by ID, which implicitly distinguishes it from the sibling list_relics. It stops short of explicitly naming that alternative, so sibling routing 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?

The phrase 'by ID' implies you should reach for this only when you already have a relic identifier, as opposed to browsing with list_relics. There is no explicit when-to-use statement, no exclusion guidance, and no mention of how the expansions parameter should influence the call.

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 of behavioral disclosure. 'Look up' implies a read-only retrieval, but nothing is said about whether lookups are exact or fuzzy, whether multiple entries can be returned, what the response contains, or what happens when the keyword is not found.

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 wasted words. It is efficient, though the brevity is part of why usage and return behavior go unaddressed.

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 no output schema, the description is minimally viable: the schema fully covers the input and the return shape need not be explained. However, it is thin for a tool among 28 siblings, offering no guidance on matching behavior or result handling.

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 'keyword' parameter is documented with two illustrative examples, so the description need not compensate. The description adds no format, casing, or matching-semantics detail beyond the schema's own 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?

Specific verb ('look up') and resource (a rule or game concept) tied to a named source, the 'TI4 Living Rules Reference'. It differentiates itself from the many get_<entity> siblings by returning prose rules rather than structured game data, though the phrase 'game concept' is broad enough to leave some ambiguity about scope.

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 statement of when to use this tool versus alternatives. The sibling 'search' tool plausibly overlaps, and nothing explains whether get_rules is for canonical rules text while search is for general queries, or what happens with partial or multi-word keywords.

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

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

No annotations are provided, so the description carries the full burden. It describes the type of content returned but omits critical behavioral details such as whether it requires an active game context, whether it is read-only, whether it may fail for unknown factions, or whether output depends on expansions. These gaps are significant for a data retrieval tool.

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

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

The description is a single, well-structured sentence that front-loads the purpose and then lists the return content. It is efficient and 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?

The tool has only 2 parameters (both documented) and no output schema, so the description must explain returns. It does list the main content types, which is adequate. However, it lacks usage context and behavioral details, leaving the agent with some uncertainty about prerequisites and alternatives.

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 the 'faction_id' and 'expansions' parameters thoroughly. The description adds no further parameter meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource ('Get structured data to help reason about faction strategy') and enumerates the data returned (starting position, key techs, home system economy, objectives). It is clear what the tool does. It does not explicitly distinguish itself from siblings like get_faction_guide or get_faction, which may cause some ambiguity.

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 use this tool versus alternatives such as get_faction_guide or get_faction. The description implies it's for strategy reasoning but doesn't specify when it should be chosen over other faction-related 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?

With no annotations, the description carries the full burden, and it does disclose the payload contents (planets, wormholes, anomalies, faction for home systems). However, it says nothing about read-only safety, error behavior for invalid tile numbers, or any other operational trait.

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

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

Two tight sentences, the action and lookup key are front-loaded, and the second sentence efficiently enumerates the returned fields. No wasted words.

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 read lookup with no output schema, the brief inventory of returned fields is enough for an agent to know what comes back. Missing only minor operational details like invalid-input handling.

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

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

Schema coverage is 100% and the tile_number parameter is documented with examples in the schema, so the description's 'by tile number' phrasing adds nothing beyond structured data. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (Get) and resource (TI4 system tile) with the lookup key (tile number), which cleanly separates it from sibling planet/faction retrievers like get_planet and get_faction. An agent can identify the tool's scope without opening the 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?

The description implies usage (look up a system tile when you have a tile number) but never states when to prefer this over get_planet/list_planets or any other alternative. No conditions, prerequisites, or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether this is a read-only operation (though strongly implied), whether it requires game context, rate limits, or anything about the return format. For a lookup tool with zero annotation coverage, this is a significant 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?

The description is a single, efficient sentence with no wasted words. It is appropriately sized but very sparse.

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 annotations and no output schema, the description should do more to explain behavior, especially around the expansions parameter and how it interacts with game context. The tool is simple (2 params), but the lack of any behavioral context leaves gaps for an 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 baseline is 3. The description adds no parameter information beyond what the schema already documents, but it doesn't need to—the schema fully describes tech_id and expansions. No credit or penalty.

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 clear verb (Get) and resource (technology details), which is adequate. However, it offers no differentiation from siblings like get_tech_path, which likely returns a related but distinct resource (tech path), leaving ambiguity about which tool to call for what.

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 use get_tech versus get_tech_path or other retrieval tools. The description provides no context, prerequisites, or exclusions to help an agent select 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?

No annotations provided, so the description carries the full behavioral burden. It notes output is organized by color with prerequisite chains, but does not disclose read-only nature, how expansions filtering affects results, or fallback behavior when faction_id is invalid. Thin for a tool with zero 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 tight sentences, front-loaded with the core purpose and closing with scope detail. No waste.

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

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

No output schema and no annotations, so the description must carry more. It gives useful output-shape hints (organized by color, prerequisite chains) but omits read-only characteristic and how expansion scoping interacts with returned results, leaving gaps for a data-retrieval tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly (including the expansions enum and omission behavior). The description adds 'faction_id' meaning by saying it includes faction-specific techs, but goes beyond little else. Baseline 3 is correct when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Get all available technologies for a faction') with additional scope ('organized by color and showing prerequisite chains'). Distinguishes from sibling get_tech by returning the faction-specific tech tree rather than presumably a single tech, though this sibling differentiation is inferred 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?

No explicit when-to-use guidance or alternatives named. The 'for a faction' phrasing implies it is the faction-scoped view vs get_tech, but this is left to inference 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?

No annotations are provided, so the description carries the burden. It discloses that filtering is optional (i.e., omitting the filter returns all cards), which is genuine behavioral context, but omits return format, pagination, and whether expansions default to game 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 front-loaded sentence with no wasted words, naming the resource first and the optional filter second. Efficient and easy to scan.

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

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

For a simple two-parameter list tool with full schema coverage and no output schema, the description is sufficient to call it correctly. The only minor gap is no mention of the expansions parameter, though the schema covers 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 100%, so both parameters are already fully documented in the schema. The description reinforces the timing_keyword filter but adds no syntax or format detail beyond what the schema states, so baseline 3 applies.

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

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

States a specific verb ('List') and resource ('TI4 action cards'), and the verb naturally distinguishes it from the sibling get_action_card (singular retrieve). It stops short of explicitly contrasting with that sibling, so it is clear but not fully 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 phrase 'optionally filtered by play timing keyword' implies when to supply the filter, which is useful. However, there is no explicit guidance on when to use this list tool versus get_action_card or the other list_* tools, leaving routing to inference.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It says nothing about read-only nature, whether results are paginated, return format, or the important expansions-default behavior (game context or base game) that determines which cards come back.

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 efficient sentence with the verb front-loaded and no filler. It is appropriately compact for a simple filtered-list tool, though it is arguably terse enough to be under-specified (a separate concern from verbosity).

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 list tool with no output schema, the description covers the primary filters but omits the expansions parameter entirely, which materially changes the result set. An agent could call it correctly via the schema, but the description alone is only 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?

Schema description coverage is 100%, so the schema already documents all three parameters including enum values and the expansions default. The description restates the type and election_type filters but adds no meaning beyond the schema, which is the baseline-3 case.

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 ('List') plus a concrete resource ('TI4 agenda cards') and an enumeration of the filterable dimensions. However, it never distinguishes itself from the sibling get_agenda or other list_* tools, so an agent must infer the bulk-vs-single distinction from the 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?

It states that filtering is optional but gives no guidance on when to use this tool versus get_agenda, nor any exclusions or prerequisites. The agent must infer usage entirely from the verb.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only list but says nothing about the significant expansions parameter, which silently falls back to game context or base game, nor about ordering, pagination, or return shape. Given the sibling tools set/clear/get_game_context, omitting this fallback behavior 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?

A single tight sentence with the resource front-loaded and the optional filter trailing. No waste, appropriate size.

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, zero-required list tool with no output schema, one sentence nearly suffices. However, the interaction between the expansions parameter and game context is never surfaced, leaving an agent to rely entirely on 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?

Schema description coverage is 100%, so both parameters (trait and expansions) are already documented in the schema, making 3 the baseline. The description enumerates the trait enum values, which merely repeats the schema, and adds nothing about the expansions 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+resource ("List TI4 exploration cards") and names the filterable dimension, clearly distinguishing it from siblings like list_action_cards or list_agendas. It is clear, though it does not explicitly contrast with other card-listing 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?

"optionally filtered by trait" implies when the trait filter is useful, but there is no guidance on when to omit trait, no mention of the expansions parameter's effect, and no named alternatives. 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?

With no annotations, the description carries the full behavioral burden. 'List all available' implies a read-only enumeration with no side effects, which is a reasonable inference, but it says nothing about return shape, ordering, pagination, or whether the guides are static versus game-state dependent.

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 verb and resource with no wasted words. Appropriate size for a zero-parameter listing 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 no-param, no-output-schema list tool this is minimally viable, but it leaves the relationship with list_factions/get_faction_guide undefined and gives no hint about what a 'strategy guide' contains or how results should be used.

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 of 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 clear verb ('List') and resource ('faction strategy guides') with a scope qualifier ('all available'). However, it does not differentiate itself from the sibling get_faction_guide or list_factions, so an agent cannot tell from the description alone whether this overlaps them.

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 indication of when to use this versus list_factions (which likely covers factions) or get_faction_guide (which likely returns a single guide). The agent must infer the intended role from the name 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?

With no annotations, the description carries the full behavioral burden. It hints that results are scoped to 'active expansions' (i.e., depends on game context), but does not state the base-game default, the read-only nature, or the return shape, so key behavioral traits remain 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 front-loaded sentence with zero filler, correctly sized for a one-parameter list tool. Every word 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 is simple and its only parameter is fully documented, but with no output schema the description could reasonably state what is returned (names, ids, or full faction objects) and how it relates to get_faction. Adequate but with a clear gap.

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

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

Schema description coverage is 100% with a single optional parameter, so the schema already enumerates the expansions and documents the default. The description's phrase 'active expansions' only loosely links to it, adding little beyond the schema; baseline 3.

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 clear verb ('List') and resource ('TI4 factions') with a scope modifier ('for the active expansions'). An agent understands the operation, but the description never differentiates it from adjacent siblings like get_faction (single faction) or list_faction_guides.

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 indication of when to use this versus get_faction or list_faction_guides, and no prerequisites. The expansion scoping is implied but the description offers no explicit context or exclusions, leaving the agent to infer routing from tool names 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?

No annotations are provided, so the description carries the full burden. It doesn't state whether results are paginated, sorted, whether expansions unexpectedly expand the result set, or what happens when get_game_context is unset. For a list tool with zero annotation coverage, 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 efficient sentence with the filter semantics front-loaded. No wasted words.

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 list tool with 100% schema coverage, this is adequate but incomplete. Without annotations, the description should at least note that filters are optional and how expansion defaults interact with the active game context, which the description never mentions.

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 baseline is 3. The description adds only marginal value by noting the type/stage filters, but it doesn't explain stage interaction with secret objectives (schema hints stage applies only to public) or the expansions default 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?

States a specific verb (List) and resource (TI4 objectives) with optional filtering described. The scope is clear enough to distinguish it from sibling get_objective (retrieves a single objective) without needing to open 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?

The description mentions optional type/stage filtering but doesn't specify when to use this tool versus get_objective or how omitted filters behave. The schema covers expansion defaults, but the description itself provides only implied usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. Beyond confirming this is a listing operation, it discloses nothing about the expansions parameter, the game-context default behavior (documented only in the schema), or what the returned planet records contain.

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 core action and its optional modifiers are stated immediately.

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 list tool with no annotations and no output schema, the description is thin: it omits the expansions parameter entirely (the one whose default depends on game context) and says nothing about the shape of results. 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 100%, so the schema already documents trait, expansions, and tech_specialty, including enum values and the game-context default. The description restates only two of the three filters and adds no syntax or format detail, 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?

Specific verb+resource (list TI4 planets) with the filtering scope stated. It implicitly distinguishes itself from the singular sibling get_planet, but does not explicitly name it.

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?

"Optionally filtered by trait or tech specialty" implies the tool's filtering use case, but there is no explicit when-to-use guidance or routing versus get_planet, get_system, or search.

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 exist, so the description carries the full burden. It implies a read-only listing but says nothing about return format, ordering, whether game context is required, or error behavior; 'active expansions' is referenced without explaining how they are determined.

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, though it is so terse that it omits any structural cues about behavior.

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 parameterless-by-default list tool with no output schema, the description covers the core action. However, it leaves the 'active expansions' concept and the relationship to get_game_context/set_game_context unexplained.

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 'expansions' parameter is fully documented with its enum options and fallback behavior. The description adds nothing beyond the schema, 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?

States a specific verb (list) and resource (TI4 relics) with a scoping qualifier (active expansions), which cleanly separates it from the singular get_relic sibling. It does not explicitly name that sibling, so a 4 rather than 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?

There is no when-to-use guidance and no mention of alternatives such as get_relic for a single relic. The phrase 'for the active expansions' hints at a context dependency but leaves the agent to infer 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?

No annotations are provided, so the description carries the full behavioral burden, and it delivers little beyond scope. It says nothing about ranking, result limits, pagination, or what a match looks like, all of which matter for a search tool with 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 sentence with the verb and scope front-loaded. The long parenthetical enumerating 16 categories largely duplicates the category enum in the schema, which is slightly wasteful but not harmful.

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 search with no annotations and no output schema, the description covers the search space but omits result behavior and when to prefer it over the many structured siblings. 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 100%, so the schema already documents query, category, and expansions. The description only restates the category list, adding no syntax or filtering semantics beyond the enum. Baseline 3 applies.

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

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

States a specific verb and resource: full-text search across all TI4 game data, and enumerates the covered domains. It does not distinguish itself from sibling tools like get_rules or the list_* tools, leaving the agent to infer that this is the fuzzy/free-text path versus exact lookups.

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 when-to-use guidance and no alternatives named. With siblings like list_factions, get_tech, and get_rules present, the agent gets no help deciding when free-text search beats a structured lookup.

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 full behavioral burden. It says the context is 'set' and affects other tools, which is useful stateful behavior, but omits whether this overwrites existing context, whether it persists across sessions, and what clearing requires (a sibling exists but is not referenced). For a stateful, dependent mutation, that is a significant disclosure gap.

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

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

Two tightly written sentences, no filler, with the effect on downstream tools 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?

It conveys purpose and downstream effect but, with no output schema and no annotations, leaves out key details an agent needs: does it overwrite prior context, how does it interact with clear_game_context and get_game_context, and any validation constraints tying players/speaker to player_count.

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 four parameters are already documented in the schema. The description adds no parameter detail beyond the schema (e.g., speaker must be a seated player, consistency between players and player_count). Baseline 3 is correct.

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 (Set) and resource (game setup context), and the second sentence names the scope: search, list_factions, get_tech_path consume it. An agent can tell this apart from get_game_context and clear_game_context without opening a 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?

Clear context for when to use: before calling tools that need expansions/player count. It implies the alternative (pass params explicitly or use get/clear context), but doesn't state exclusions such as when calling this is unnecessary because context is already set.

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 behavioral burden. It discloses output contents (draft pool, strategy cards, speaker order), a useful trait, but does not state whether setup is deterministic/random (only 'random faction draft pool' is noted), whether it mutates game state, or reads vs. writes. Enough to be usable but with 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?

Three compact sentences: purpose, outputs, and default behavior. Front-loaded with the core action and every sentence conveys information without redundancy.

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 generation tool with no output schema and no annotations, the description adequately states what is produced and default behavior. It stops short of documenting return structure or mutation side effects, but it provides enough for an agent to invoke 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 schema already defines player_count, expansions, and faction_pool_size with ranges, defaults, and enum options. The description adds only a high-level summary of defaults ('Player count and expansions default to game context') and doesn't clarify per-parameter syntax beyond the schema. 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?

Specific verb+resource: 'Generate a game setup for N players.' Explicitly names the concrete outputs (faction draft pool, strategy cards, speaker order), which distinguishes it from sibling generators like suggest_map and analyze_slices. An agent can identify this as the setup-creation tool without opening the 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?

Provides implied context ('The LLM can then reason about balance and strategy') and default behavior tied to game context, which hints at when it's used as a starting point. However, it never states when to prefer this over siblings, nor when not to use it, nor prerequisites.

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 discloses that tiles are randomly selected and returns blue and red tiles, but doesn't cover determinism, whether results can be regenerated, or any constraints on the tile pool. Adequate but not rich for a tool with zero 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 tight sentences with no waste. The core purpose is front-loaded, and the routing guidance follows immediately, making it easy to scan.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers what the tool does, its output shape (blue and red tiles), and its alternative. It could say more about randomness or result format, but it's sufficient 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 100% and the single parameter player_count is fully documented in the schema, including its default behavior. The description adds no parameter syntax or format details beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific action (suggest a random map tile selection) with the resource and scope (for a given player count). It distinguishes itself from the purely analytical analyze_slices, but the connection to sibling tools is only partially clarified. The purpose is clear enough to act on.

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 routes agents away from this tool for draft-based maps, naming Milty Draft and analyze_slices as the alternatives. It gives a clear when-not condition, though it doesn't state when this quick suggestion is preferable beyond the implicit casual use case.

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