Moddable Games Tools

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

No annotations are provided, so the description carries the burden. The verb 'Get' clearly indicates a read-only operation, but no additional behavioral context is given (e.g., what happens if the ID is not found, whether it returns partial data, or any error conditions). It is minimally transparent but not misleading.

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 concise sentence that immediately states the action and target. There is no wasted wording, and the structure is perfectly efficient for a simple getter 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 tool with one parameter, full schema coverage, no output schema, and no annotations, the description provides sufficient context for an agent to understand what it does and what input to provide. It could mention what 'details' includes, but the simplicity of the tool keeps this from being a significant gap.

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

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

The schema already describes the 'board' parameter as 'Board ID or name', which covers 100% of the parameter semantics. The description only adds 'by ID' while the schema says 'ID or name', which is a slight narrowing but not a contradiction. The description does not add extra meaning beyond the schema beyond this minor detail.

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

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

The description clearly states the verb 'Get', the resource 'board layout', and the means of identification 'by ID'. It distinguishes this from sibling tools like board_gallery_search (which likely lists or finds boards) and board_gallery_stats (which provides statistics).

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 that this tool is for retrieving a single known board layout, but it does not explicitly state when to use this versus searching or when not to use it. There is no mention of alternatives or exclusions, though the context is reasonably clear for a simple getter.

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 verb 'search' implies a read-only operation, and the count of indexed content adds useful context. However, with no annotations, the description does not disclose return format, ordering, pagination, or behavior when query is omitted.

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 that front-loads the verb and resource, with the parenthetical count adding meaningful scope without wasted words. Every part 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 two-parameter search with full schema coverage, the description is mostly sufficient. However, there is no output schema and the description does not mention what the search returns or suggest using board_gallery_get for details on a specific board.

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?

Both parameters are fully documented in the schema with descriptions, types, defaults, and examples, so schema coverage is 100%. The description adds no additional parameter semantics, but none are needed here.

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

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

The description states a specific verb ('Search') and resource ('the board gallery'), with extra precision via the count of layouts and game families. It clearly distinguishes from board_gallery_get and board_gallery_stats by indicating a search operation, though it doesn't explicitly contrast with piece_gallery_search or tile_gallery_search.

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

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

The description gives no guidance on when to use this tool versus alternatives such as board_gallery_get, board_gallery_stats, or the other gallery searches. The sibling list exists, but the description itself offers no selection criteria or exclusions.

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

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

No annotations are provided, so the description carries the burden. It does disclose the basic behavior of returning aggregate counts, which implies a read-only operation, but it does not describe the return format or explicitly confirm non-mutating behavior. This is minimal but not misleading.

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, tightly written sentence with the verb and resource front-loaded. Every word adds value and there is no filler.

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

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

For a zero-parameter stats tool, the description lists the main output categories (total boards, families, topologies), which is mostly sufficient. However, there is no output schema, so a note about the return format (e.g., a single object with these counts) would improve completeness.

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

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

The tool has zero parameters, so the description has no parameters to explain. A baseline of 4 is appropriate because no parameter documentation is 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 uses a specific verb ('Get statistics') and names the resource ('board gallery') with concrete contents (total boards, families, topologies). This clearly distinguishes it from sibling tools like board_gallery_get and board_gallery_search.

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 use case is implied by the word 'statistics' — an agent would know to use this when aggregate counts are needed. However, there is no explicit guidance about when to prefer this over get/search variants or similar stats tools for other galleries.

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 must convey behavioral traits. It discloses the deprecated status and removal version, which is valuable lifecycle transparency. However, it does not state whether the tool still functions, returns data, or has any side effects, leaving operational behavior unclear.

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 sentence that front-loads the deprecation warning and alternative, with no unnecessary words. It is extremely concise and well-structured.

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 effectively redirects agents to the replacement tool, which is the most important contextual information for a deprecated tool. However, if an agent still needs to invoke it, the description lacks parameter explanations, return format, or behavioral details, so it is only minimally 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?

The schema has two parameters (depth, variant) with zero description coverage. The description does not mention either parameter, providing no additional meaning about how to set them or what values are expected.

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

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

The description states the tool analyzes a chess position, which is a clear verb+resource action. It also labels the tool as deprecated and points to play_suggest_move as the intended replacement, which distinguishes it from sibling tools. However, 'analyse' is somewhat generic, lacking specifics on what analysis is performed.

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 instructs to use play_suggest_move instead and notes removal in v1.0.0, providing clear when-not-to-use guidance and an alternative. This fully satisfies the usage guidance dimension.

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 disclosure burden. It discloses a key limitation (variant puzzles have no themes, max rating 1400, hard difficulty only applies to standard) but does not mention return format, error behavior, or state effects.

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 crisp sentences. The first states the main action and filters; the second explains an important edge case. Every word contributes, and key information is front-loaded.

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

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

For a simple random-getter tool with three optional params and no output schema, the description covers the essential filtering constraints and variant limitations. It lacks explicit return-value or no-match behavior details, but is otherwise reasonably complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable cross-parameter semantics: it clarifies how variant interacts with theme and difficulty, which the individual schema descriptions do not fully 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 uses a specific verb 'Get' with a clear resource ('random chess puzzle') and immediately names the filtering dimensions (variant, difficulty). This distinguishes it from siblings like chess_list_puzzle_types and chess_analyze_position, which serve different purposes.

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 provides clear usage context by stating how to filter and what to expect for variant puzzles. It does not explicitly name alternative tools or when-not-to-use conditions, but the context is strong enough for an agent to know when this tool is appropriate.

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 deprecation and removal, but does not mention any side effects or return format. For a simple getter, 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?

One sentence plus a clear deprecation note. Every word is useful; no fluff.

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

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

Given it's a deprecated tool, the description covers the essential alternative. It lacks parameter explanation but is otherwise reasonably complete for a simple getter.

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

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

Schema description coverage is 0%, and the description does not explain the 'variant' parameter. The agent is left to infer what values are valid, making this a significant gap.

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

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

The description clearly states 'Get legal moves for a chess position' with a specific verb and resource. It also identifies itself as deprecated, which distinguishes it from siblings like play_get_moves.

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 states 'DEPRECATED — use play_create_game + play_get_moves', giving direct alternative guidance. It also notes removal version, which helps with planning.

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. It transparently warns that the tool is broken and non-functional, which is the critical behavioral 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?

The description is extremely concise, with the critical 'REMOVED' warning front-loaded. 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?

For a broken tool with no replacement, the description fully communicates the necessary context: it is removed, broken, and should not be used. No additional detail is needed.

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 description does not explain the 'variant' parameter, and schema description coverage is 0%. While the tool's brokenness makes parameters irrelevant, the definition still fails to add meaning beyond the schema.

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

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

The description clearly identifies the tool as removed/broken, and 'Opening book resolution' indicates the intended resource/action. It distinguishes this tool from siblings by flagging it as non-functional.

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 states the tool is 'broken' and that there is 'No replacement,' telling the agent never to use this tool. This is clear when-not-to-use 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?

With no annotations provided, the description carries the full transparency burden. It only mentions deprecation and removal, which is a behavioral trait, but gives no information about side effects, read-only nature, or expected return format. This is a significant gap for a tool that may still be invoked.

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 concise and front-loaded with the deprecation warning, which is the most critical information. However, it could have included a brief mention of the 'variant' parameter without losing conciseness.

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

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

Given the lack of annotations, output schema, and parameter documentation, the description is incomplete for a functional tool. The deprecation note mitigates this somewhat by redirecting users, but the tool itself remains under-specified.

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 has a single 'variant' parameter with no description, and schema_description_coverage is 0%. The description does not mention the parameter at all, leaving the agent without any guidance on what values are valid or how the parameter affects the status.

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 clearly states 'Get chess game status' with a specific verb and resource, and the deprecation note distinguishes it from the alternative play_check_status. However, it does not elaborate on what 'status' encompasses, making it somewhat vague but still functional.

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 directs users to use play_check_status instead and gives a removal timeline ('Removal: v1.0.0'), providing clear guidance on when not to use this tool and what alternative to choose.

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. 'List' implies a read-only operation with no side effects, but the description does not explicitly state this. It does disclose that it returns per-variant counts, which is useful behavioral context, though it lacks detail on ordering, empty results, or underlying data source behavior.

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

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

The description is a single, concise sentence that front-loads the action ('List') and clearly specifies the object and the additional detail of per-variant counts. Every word contributes value, and there is no fluff or repetition.

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 listing tool, the description covers the core functionality well. It tells the user what will be listed (variants, themes, counts) and the source (puzzle pool). It does not specify the exact return format, but the description's mention of counts gives a good indication. No output schema exists, so a bit more detail about the response structure could be added, but this is a minor gap given the tool's simplicity.

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

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

The tool has zero parameters, so per the guidelines, the baseline is 4. There is no parameter semantics to define, and the description appropriately avoids inventing any. The schema already shows an empty parameter object, so the description adds no redundant information.

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

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

The description uses a specific verb 'List' and a specific resource: 'available puzzle variants, themes, and per-variant counts from the puzzle pool'. This clearly distinguishes it from sibling tools like 'chess_generate_puzzle' or 'chess_list_variants', though it does not explicitly name alternatives. The scope is clear and helpful.

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 that this tool is used when you need an overview of puzzle variants, themes, or counts. However, it provides no explicit guidance on when to use this tool instead of related tools such as 'chess_list_variants' or 'chess_generate_puzzle'. There are no alternative suggestions or exclusion criteria.

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 the deprecation status and the core listing behavior, but does not mention any other behavioral traits (e.g., filtering, grouping, output format). For a simple listing tool, this is adequate but lacks depth.

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 deprecation warning and replacement, then a minimal functional description. No wasted words; each segment serves a purpose.

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 deprecated tool, the description is nearly complete: it tells you not to use it, what it does, and where to go instead. The only missing piece is the parameter semantics, which is partially excused by the deprecated status but still leaves a 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 coverage is 0%, and the description does not mention the 'group' parameter at all. There is no added meaning about what the parameter does or how it affects results. This is a significant gap.

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

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

The description clearly states the tool's function: 'List chess variants.' The deprecation notice and pointer to 'play_list_variants' make the purpose unambiguous and distinguish it from the sibling tool that replaces 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?

Explicitly instructs to 'use play_list_variants' instead, giving a clear alternative and indicating when NOT to use this tool (since it's deprecated). This is strong 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?

With no annotations, the description carries the burden. It discloses the deprecation status and that it applies a move, but it does not mention any side effects, error conditions, or requirements. The deprecation notice is valuable, but other behavioral details are absent.

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 extremely concise and front-loaded with the most important information (deprecation). Every segment earns its place: the deprecation warning, the alternative tool, the action, and the removal version.

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 deprecated tool, the description adequately redirects to the alternative, but it lacks essential details for actually using the tool if the deprecation is ignored (e.g., move object structure, variant values, return format). Given the simple schema but empty parameter descriptions, this is a partial 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 0%, and the description does not explain the 'move' object or 'variant' string parameters. The agent is left without any guidance on what values these parameters accept, making the tool difficult to invoke correctly.

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 clearly states the tool's function: "Apply a move to a chess game." It also explicitly labels itself as deprecated and points to the replacement (play_apply_move), which distinguishes it from sibling tools like chess_make_moves.

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 tells the agent not to use this tool and to use play_apply_move instead, along with a removal version. This is unambiguous guidance on when to use the alternative.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It notes the deprecation and removal version, but does not describe side effects, whether it mutates game state, or what it returns. The implied write behavior is not explicitly disclosed.

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 compact and front-loaded with the deprecation warning. It uses two short sentences with no wasted words. However, it omits critical details, making it under-specified rather than truly 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 deprecated tool, the description is adequate: it states the action, deprecation, alternative, and removal version. But given the lack of annotations, output schema, and parameter documentation, it is not complete enough for an agent that must actually invoke it. The deprecation redirect reduces the need for full invocation details, so it is minimally viable.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'a sequence of chess moves', which vaguely maps to the 'moves' param but provides no format, structure, or meaning for the 'variant' param. The input schema's raw property names offer no additional clarity.

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 clearly states the action ('Apply a sequence of chess moves') with a specific resource (moves) and distinguishes from siblings via the deprecation notice pointing to play_make_moves. The verb 'apply' is slightly generic but the overall purpose is unambiguous.

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

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

The description explicitly instructs not to use this tool ('DEPRECATED') and names the preferred alternative ('use play_make_moves'). This provides clear when-not-to-use and alternative guidance, exceeding the baseline.

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 burden of behavioral disclosure. It reveals the tool is deprecated and will be removed in v1.0.0, which is important context. It doesn't discuss return format or side effects, but for a rendering tool this is a minor 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 exceptionally concise, using two sentences to convey function, deprecation, and replacement. It is front-loaded with the deprecation warning, making it highly efficient.

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

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

For a simple, deprecated rendering tool, the description covers the essential context: what it does, that it's deprecated, and what to use instead. Lack of output format details is acceptable given the tool's simplicity and deprecation.

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 description adds no parameter semantics beyond the schema. Schema coverage is 67%, leaving 'variant' undocumented, and the description does not clarify it. The deprecation notice reduces the need for param details, but the description itself contributes nothing.

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 clearly identifies the tool's function: 'Render a chess position as SVG.' It also names the replacement tool, play_render_board, which distinguishes it from siblings and provides immediate context.

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

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

The deprecation notice explicitly says 'use play_render_board,' giving clear when-not-to-use guidance and naming the alternative. This is the strongest form of 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 behavioral disclosure burden. It adds a useful deprecation and removal timeline, which is a behavioral trait. However, it does not disclose whether the tool is read-only, what side effects it might have, or what it returns, leaving gaps in transparency.

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 concise, consisting of two short sentences. The deprecation warning is front-loaded, and every word earns its place. It is not over-verbose or under-specified in terms of prose length.

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 a nested object parameter, no output schema, and no annotations, so the description must be comprehensive. It provides a deprecation note but omits parameter details and return-value information. This is incomplete for actual invocation, though the deprecation guidance adds some value.

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 schema has 2 parameters with no descriptions (0% coverage). The description provides no additional meaning about the 'move' object structure or the 'variant' string. It fails to compensate for the lack of parameter documentation, making parameter semantics completely inadequate.

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 clearly states the tool's function: 'Check if a chess move is legal.' This is a specific verb+resource statement. The deprecation note explicitly distinguishes it from the sibling tool play_validate_move, which is the intended replacement.

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 'DEPRECATED — use play_validate_move' and specifies the removal version, providing clear when-not-to-use guidance and naming the alternative tool. This fully satisfies the criterion for explicit 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 should disclose behavioral traits. It states the action (flipping/picking) but does not explicitly mention that the result is random, non-deterministic, or that it has no side effects. Given the simplicity of the tool, the implied behavior is adequate, but there is room for more transparency.

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, concise sentence that communicates the entire purpose without unnecessary words or repetition. It is well front-loaded and contains no filler.

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

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

For a simple tool with a fully described schema and no output schema, the description is sufficient. It covers the two main use cases and does not leave major gaps. However, it could optionally mention what the return value looks like, which is omitted.

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

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

Schema description coverage is 100% with both parameters (count and choices) clearly described. The description adds minimal additional meaning beyond the schema—it reiterates the concepts of 'one or more coins' and 'list of choices.' This aligns with the baseline of 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?

The description clearly states the tool's function with specific verbs and resources: 'Flip one or more coins, or pick from a list of choices.' This directly distinguishes it from sibling random tools like dice_roll and oracle_roll, which serve different purposes.

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 when to use this tool (when a coin flip or random choice from a list is needed) but does not explicitly provide alternatives or exclusions. It lacks guidance on when to use this instead of other random tools, though the context is reasonably inferred.

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

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

No annotations are provided, so the description carries the full burden. 'Calculate' implies a read-only operation, which is helpful. However, it does not disclose the output format (e.g., percentage, probability distribution), edge cases, or any constraints on input values beyond what the schema shows.

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, front-loaded sentence with no filler. It conveys the verb and resource efficiently and is appropriately sized for a tool with one parameter.

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

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

With one parameter and no output schema, the description explains what the tool does but not what it returns. An agent can invoke it correctly but may be uncertain about interpreting the result. It is adequate but not fully complete.

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

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

The schema description coverage is 100% for the single parameter 'numbers', with a clear example. The description adds no extra meaning beyond that, so baseline 3 applies.

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

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

The description uses a specific verb 'Calculate' and identifies the exact resource ('settlement dice probability for Colony/Catan-style resource numbers'). It clearly distinguishes this from sibling 'dice_odds' by scoping to settlement numbers in a specific game context.

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

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

It clearly implies the tool is for Catan-style settlement probability calculations, which tells an agent when to use it. However, it does not explicitly mention alternatives (e.g., generic 'dice_odds') or exclude other uses, so it lacks direct when-not-to-use 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?

With no annotations, the description carries the full burden. It states the core behavior and notes keep-high/low support, but does not disclose output format, error behavior, or that it's a pure calculation with no side effects. This is a moderate gap.

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

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

A single, front-loaded sentence that states the purpose and a key feature. Every word earns its place, 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?

For a simple probability calculator with complete schema coverage, the description is mostly sufficient. It explains the core function and provides an example. However, it does not address output format or how it differs from the similar-sounding colony_dice_odds, leaving 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 description coverage is 100% and already includes the 4d6kh3 example. The description's mention of keep-high/low adds no new semantic value beyond the schema, so it stays at baseline.

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

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

The description uses a specific verb + resource: 'Calculate probability of meeting a target with a dice expression.' It clearly distinguishes from sibling tools like dice_roll (which rolls dice) and colony_dice_odds (which is likely domain-specific). The inclusion of a concrete example (4d6kh3) reinforces the purpose.

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 use for probability calculations rather than actual rolling, which provides clear context among siblings. However, it does not explicitly state when not to use it or name alternative tools, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It lists supported features (comma-separated pools, keep/high-low) but does not describe the return format, error behavior, or randomness characteristics. This is a partial gap in transparency.

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, front-loaded with the core action, and uses clear examples. Every word earns its place with no fluff or 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 simple dice-rolling tool, the description covers the main capability and supported syntax. It lacks explicit return-value details and edge-case handling, but given the tool's simplicity and complete parameter schema, this is a minor shortfall.

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%, with each parameter already described in the schema. The description adds examples and clarifies the notation syntax, but does not elaborate on the 'count' parameter or the relationship between 'notation' and 'expression'. 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 clearly states the tool's purpose with a specific verb ('Roll dice') and resource, and provides concrete examples. It distinguishes itself from siblings like dice_odds (which calculates odds) and coin_flip by focusing on standard dice notation.

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 clear context for using this tool (rolling dice with standard notation) and implies it is for rolling, not for calculating odds. However, it does not explicitly mention alternatives or when not to use it, leaving some room for ambiguity.

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

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

No annotations are provided, so the description carries full responsibility. It discloses that the tool can create, shuffle, and optionally draw/deal, but does not explain state changes, return format, or side effects of creation. It adds basic behavioral detail but lacks depth for a mutating tool.

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

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

A single 10-word sentence efficiently conveys the core operations without redundancy or unnecessary details.

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?

Despite the low required parameter count, the tool supports multiple operations and has no output schema or annotations to fall back on. The description doesn't explain what 'create' returns, how hands and per_hand interact, or default behavior, leaving a substantial 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 coverage is 100%, so the schema already documents all four parameters. The description adds no additional parameter semantics beyond the general 'draw/deal' concept, leaving the baseline at 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?

The description uses specific verbs (create, shuffle, draw/deal) with a clear resource (card deck), making its purpose immediately evident. It distinguishes from sibling tools like coin_flip or dice_roll by focusing on card deck operations.

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 context for card deck operations but does not explicitly state when to prefer this over alternatives, nor does it mention exclusions or prerequisites. Usage is implied from the tool name and description, not explicitly guided.

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. It mentions shuffling and dealing, but does not disclose the return format, whether the operation has side effects on an existing deck, or how the draw and hands modes behave beyond the schema. This is a significant gap for a tool with multiple execution modes.

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 concise sentence that effectively communicates the core behavior without any redundant or irrelevant text.

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, combined with the fully described schema, provides enough context for a straightforward dealing operation. It lacks explicit mention of output format or use cases, but the schema covers the parameter variants. Since there is no output schema, a brief note on return value would improve completeness, but the current state is adequate for a simple tool.

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

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

The input schema provides 100% coverage with descriptions for all four parameters (cards, draw, hands, per_hand), so the description adds little beyond the notion of a 'custom deck of arbitrary named cards'. Baseline 3 is appropriate because the schema handles parameter explanation.

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 clearly states the tool shuffles and deals a custom deck of named cards, using an active verb and specific resource. It distinguishes the tool from siblings like game_deck_create (which creates decks) and coin_flip, which are for other random operations.

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 is provided on when to use this tool versus alternatives, such as game_deck_create or other random generators. The description only states what the tool does, with no explicit when-to-use or when-not-to-use conditions.

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 provided, the description carries the transparency burden. It discloses that the operation is a listing ('List') and that output includes metadata, but it does not detail return format, potential errors, or any other behavioral characteristics. This is minimal but acceptable for a straightforward read-only 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 concise sentence, front-loaded with the verb and resource, with no wasted words. 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?

Given the low complexity (no parameters, no output schema, no annotations), the description provides the essential purpose and hints at metadata content. It is complete enough for the agent to select and invoke the tool correctly, though more detail about metadata fields could slightly improve it.

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

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

The tool has no parameters, so the baseline is 4. The description appropriately omits parameter details, and since schema coverage is trivially 100%, there is no additional burden to meet.

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'), identifies the resource ('deck types'), and scopes it ('all'), with additional detail about metadata content. This clearly distinguishes it from sibling tools like game_deck_create, which creates rather than lists.

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 (use this to list available deck types) but provides no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. For a simple zero-parameter tool, this is adequate but not proactive.

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?

Without annotations, the description carries the burden. It discloses the randomness and the output composition ('combining mechanics and themes'), but does not explain the return format or any side effects. This is minimal but not misleading.

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 concise sentence with no redundant words. It is front-loaded and easy to parse.

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

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

The tool is simple, but the description fails to mention the output format (string vs. structured) or how it relates to neighboring jam_* tools. Since there is no output schema and no annotations, this gap leaves the agent with uncertainty about the response.

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% for the single 'count' parameter, including its default value. The description adds no extra semantics beyond the schema, so 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 'generate' and a clear resource 'random game jam theme', with an additional detail about combining mechanics and themes. This distinguishes it from other random tools like dice_roll or coin_flip.

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 is provided on when to use this tool versus alternatives. With many random generator siblings, the description gives no context for selection.

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 provided, the description carries the full burden of behavioral disclosure. It only says 'resolve combat' without explaining what happens (e.g., whether outcomes are random, if modifiers apply, if units are consumed), what the result looks like, or any side effects. This is a significant gap for a combat resolution 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, concise sentence that front-loads the core action ('Resolve a Nukes combat encounter'). It does not waste words or repeat schema details, earning its place. However, its brevity comes at the cost of missing broader context, so it is not a top score.

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

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

Given the tool's complexity (combat resolution with 3 parameters and no output schema), the description is incomplete. It does not explain the outcome format, whether the result is deterministic or random, or what inputs influence the result. The description is too sparse to fully inform an agent on expectations, especially with no annotations to fill 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?

The input schema has 100% coverage with descriptions for all parameters (terrain, attacker, defender), so the schema already provides the meaning. The description does not add any additional semantic value beyond what the schema states, but it does not need to, 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?

The description clearly identifies the action ('Resolve') and the specific resource ('a Nukes combat encounter between units'), which distinguishes it from other game tools like dice rolls or random encounters. It lacks explicit differentiation from sibling tools, but the 'Nukes' qualifier provides enough specificity for a user to understand its 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?

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. There is no statement like 'use for combat resolution' or 'for other Nukes actions, see...'. It gives no usage direction beyond the action itself.

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. It doesn't state whether this is a read-only operation, whether it persists state, what it returns, or any side effects. 'Track' implies some mutating action, but the details are absent.

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 sentence with no wasted words, front-loading the core purpose. It is appropriately concise, though it could be slightly more informative without becoming verbose.

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

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

Given the simplicity of the schema (3 params, no output schema) and no annotations, the description is too minimal to be complete. It doesn't explain return values, persistence, or how the tool behaves in practice, which is essential for an agent to use 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 adds no information about the parameters beyond what the schema already provides; it merely repeats the notion of scores and players. The schema itself adequately documents the properties.

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 'Track scores for players in any game' clearly states the verb (track), the resource (scores for players), and the scope (any game). It distinguishes this tool from siblings that focus on other game mechanics like dice rolls or chess moves, though it could be more specific about the exact functionality.

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 is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or any relationship to other game-related tools. The agent is left without context for appropriate 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?

No annotations exist, so the description must carry the full behavioral burden. It does not disclose how obstacles or map seeds affect the result, what the return format is, or whether this is a read-only operation. The one-line description adds minimal behavioral context beyond the name.

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 filler. It is appropriately sized for the limited information it conveys.

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 5 parameters, optional game/seed context, and no output schema. The description is too terse to be complete; it omits key details about obstacle handling, return format, and how optional parameters affect behavior. For a tool with this complexity, a richer description is expected.

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 meaningful parameter descriptions (e.g., 'Origin Q coordinate', 'Vision range in hexes'). The description adds no additional meaning beyond the schema, so 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 'Compute field of view from a hex position' uses a specific verb ('compute') and identifies the resource ('field of view from a hex position'). It is distinct from sibling tools like hex_pathfind and hex_generate_map, though it could more explicitly state the output scope (e.g., visible hex set).

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 this tool versus alternatives such as hex_pathfind or hex_get_info. The optional 'game' and 'seed' parameters hint at obstacle-aware FOV, but the description does not explain the intended context or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose any behavioral traits such as whether the tool returns an SVG string or writes a file, whether it requires an existing map, or any side effects. The description merely restates the action without additional 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?

The description is a single, concise sentence that is front-loaded with the main action. Every word contributes, and it avoids unnecessary detail.

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

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

With six parameters, no output schema, and no annotations, the description is too sparse. It does not explain the return format, whether the SVG is saved or returned, or how parameters influence the output. This leaves significant ambiguity for an agent trying to use 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 all six parameters are described in the input schema. The description adds no additional meaning to the parameters, so the baseline score 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 clearly states the tool generates a hex map and exports it as SVG, which is a specific verb+resource+format. It is distinguishable from hex_generate_map by the SVG export aspect, but the wording 'Generate a hex map and export as SVG' is slightly ambiguous about whether it only exports an existing map or creates the map from scratch, so it lacks full distinction from related 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?

No guidance is provided about when to use this tool versus alternatives like hex_generate_map or hex_pathfind. The description simply states the function without giving context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention what the tool returns, any side effects, randomness/determinism beyond the seed parameter, or output format. The schema mentions 'Random seed for reproducibility' but the description itself adds no transparency.

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, front-loaded sentence with no unnecessary words. It states the action and key modifiers efficiently, making it easy for an agent to parse quickly.

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?

Despite having only 4 parameters and no output schema, the description is too sparse. It fails to describe the return value or the effect of generating a map, which is critical for an agent to correctly invoke the tool. The schema covers inputs but not outputs, and the description does not fill that 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% as all 4 parameters have descriptions. Since the schema fully documents each parameter, the baseline is 3. The description adds minimal semantic value by highlighting game and player count, but does not explain parameter formats or defaults beyond what the schema already states.

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

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

The description says 'Generate a hex map for a specific game and player count', which is a specific verb (Generate) + resource (hex map) + scope (specific game and player count). It distinguishes from sibling tools like hex_export_svg (exporting) and hex_get_info (getting info) by clearly indicating a new map generation action.

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

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

The description provides no guidance on when to use this tool vs alternatives. It does not mention contexts like 'Use hex_get_info for existing maps' or 'Use hex_export_svg to convert maps', leaving the agent to infer usage solely from the action itself.

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 must fully convey behavioral semantics. It states the action 'Get info' (implying read-only), but does not disclose prerequisites (e.g., whether game/seed are needed for terrain lookup), the exact return structure, or side effects. This is insufficient for an unannotated tool.

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

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

The description is a single, concise sentence that immediately conveys the core function and relevant details, with no superfluous 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?

Given no output schema, the description partially addresses return contents (terrain, neighbours, distance) but leaves gaps: 'distance' is ambiguous (distance to what?), and the optional parameters game and seed are not explained in terms of necessity or impact. The tool is simple but not fully specified.

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 descriptions for all parameters exist. The tool description adds no additional meaning beyond listing the output fields (terrain, neighbours, distance), which does not directly explain parameter behavior. 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?

The description clearly identifies the tool's purpose: retrieving info about a specific hex coordinate, listing the exact data (terrain, neighbours, distance). This distinguishes it from sibling tools like hex_pathfind or hex_compute_fov, which focus on other aspects.

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 use when one needs coordinate-based hex info, but it doesn't explicitly mention when to prefer this tool over alternatives like hex_pathfind or hex_compute_fov. No exclusions or alternative guidance is provided.

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. It only states the basic action without addressing side effects, error conditions, response format, or potential costs. The detail 'with configuration options' hints at output structure but provides minimal behavioral 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?

The description is a single sentence with no filler, directly and efficiently stating the tool's purpose. It is appropriately sized for a simple no-parameter list 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?

The description covers the core purpose but lacks details about the return value format, what 'configuration options' specifically include, and any prerequisites or edge cases. For a simple list tool with no params and no output schema, it is minimally viable but leaves ambiguity about the exact output structure.

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 description is not required to explain any. The mention of 'configuration options' likely refers to output content rather than input, and the description adds no confusion. Baseline 4 applies for zero-parameter 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 the specific verb 'List' and clearly identifies the resource ('available hex map game types'), making the tool's function unambiguous. It distinguishes from siblings like hex_generate_map (which creates maps) and hex_get_info (likely retrieves info about a specific map), though it doesn't explicitly name 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of when to choose this over other listing tools (e.g., rules_list_games, oracle_list_games) or related hex tools, leaving the agent to infer 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?

No annotations are provided, so the description carries full burden. It states only 'Find shortest path' and does not disclose return format, effect of game/seed on movement costs, failure behavior, or side effects.

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 or redundant information. It is appropriately concise 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?

The description is too minimal given six parameters, no output schema, and no annotations. It omits return value details, the role of game/seed in movement costs, and assumptions about the hex grid, making it incomplete for reliable 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 baseline 3 applies. The description adds little beyond the schema's minimal parameter descriptions, especially for 'game' and 'seed', but it does not need to compensate for missing schema fields.

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 clearly states the tool's action ('Find shortest path') and resource ('between two hex coordinates'). This distinguishes it from sibling hex tools like hex_compute_fov or hex_generate_map.

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 context is implied by the name and description, but there is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites or when game/seed context matters.

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 provided, the description carries the full burden of behavioral disclosure. It indicates a read action via 'Get' and specifies the returned fields, but it does not explicitly state that it is non-mutating or describe behavior when there is no active jam. The absence of side-effect warnings is acceptable for a getter but leaves some 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?

The description is a single sentence that front-loads the core purpose and includes concrete detail (active jam, deadline, submissions) without any filler. Every word contributes to understanding.

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

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

For a simple, zero-parameter tool with no output schema, the description adequately covers what the user can expect to receive: status, deadline, and submissions. It could be more explicit about edge cases (e.g., no current jam) but is otherwise complete given the low complexity.

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

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

The tool has zero parameters, so the schema places no burden on the description. The baseline for 0 parameter tools is 4, and the description naturally has no need to elaborate on parameter meanings.

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 clearly states the tool's function with a specific verb ('Get'), the resource ('current Mod Jam status'), and the included data points (active jam, deadline, submissions). This distinguishes it from sibling tools like jam_timer or jam_vote, which target different aspects of the jam.

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 'current Mod Jam status' provides clear context for when to use this tool (whenever current status info is needed). However, it does not explicitly mention when not to use it or offer alternatives, though the sibling names make some differentiation 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?

With no annotations, the description carries the full burden. It conveys a read-only operation via 'Get' but does not disclose edge-case behaviors such as what happens when no Mod Jam is active, whether it returns time in seconds/minutes, or if it could error. The tool is simple, but these missing details prevent a higher score.

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, front-loaded sentence with no redundant words. It efficiently states exactly what the tool does and earns its place without any 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?

With no output schema, the description should describe the return format (e.g., seconds, formatted time, or null if no jam). It fails to mention units or behavior in edge cases, leaving a significant completeness gap for such a simple tool.

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

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

The tool has zero parameters, so the input schema is trivially fully covered. The description adds no parameter information because none is needed. Per the rubric, a baseline of 4 applies for tools with no parameters.

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 'Get time remaining in the current Mod Jam' uses a specific verb ('Get') and clearly identifies the resource (time remaining) and scope (current Mod Jam). It distinguishes itself from siblings like jam_status and game_jam_theme by focusing on the countdown aspect.

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: you call it when you need the time remaining in the current Mod Jam. However, it provides no explicit guidance on when to prefer this over related tools (e.g., jam_status) or any exclusions, so it's only implied rather than explicitly 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?

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation but does not describe the output format, potential side effects, or any special behavior.

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

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

The description is a single concise sentence that directly states the tool's purpose without any filler or 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?

Given the tool's simplicity (zero parameters, no output schema), the description is adequate. However, it could be more complete by clarifying what 'voting status' encompasses, but this is a minor gap for a simple read 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?

The tool has zero parameters, so the schema is trivially complete. The description adds no parameter information, but none is needed since there are no parameters.

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 clearly states the action ('Get') and resource ('voting status') with a specific scope ('current Mod Jam'). It distinguishes from sibling tools like jam_status and jam_timer by focusing specifically on voting.

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 is provided on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or situations where another tool would be more appropriate.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only states that it generates a random setup, but gives no details about the return format, side effects, or whether it is a pure read-only 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?

The description is a single, front-loaded sentence with no filler or redundant information. It is appropriately sized for the tool's simplicity.

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 with one optional parameter, and the schema handles parameter details. However, there is no output schema and the description does not explain what a 'territory/resource setup' includes, leaving some ambiguity about the return value.

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 fully documents the single 'players' parameter with its range (2-6) and default value (2), so the description does not need to add much. Since schema coverage is 100%, the baseline score 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?

The description uses a specific verb ('Generate') and a clear resource ('random territory/resource setup for a Nukes game'), which makes the tool's function immediately obvious. It distinguishes itself from sibling tools like game_nukes_combat by focusing on setup generation rather than combat.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description implies it is used for setting up a Nukes game, but it does not mention exclusions or alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only describes the input concept and does not mention whether the outcome is random, how the likelihood modifier affects the result, or what kind of response the agent should expect. This is a notable 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?

Single sentence, completely to the point, with no redundant wording. The description is well-structured and front-loaded with the essential 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?

Given the tool's simplicity (2 params, no output schema), the description covers the core function but lacks detail about return values or behavioral edge cases. It is minimally viable but could be improved by referencing sibling tools or clarifying output.

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?

Both parameters are fully described in the schema (question text and likelihood enum with default), so the description adds little beyond paraphrasing. Schema coverage is 100%, 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?

Clearly states the action (ask), resource (oracle), and specific scope (yes/no question with likelihood modifier). Distinguishes from sibling oracle tools like oracle_roll or oracle_scene by focusing on the yes/no question format.

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 for yes/no questions with a likelihood modifier, giving clear context for when to use it. However, it does not explicitly mention alternatives or exclusions, so it stops short of full 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 burden. It discloses that the output includes CR-appropriate monsters, terrain, and loot, but it does not explain return format, randomness, how party_level/difficulty affect CR, or any failure modes. The description adds some behavioral context but lacks depth for a tool with zero annotation support.

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 sentence, front-loaded with the action ('Generate'), and every word contributes meaning. It packs key information (output elements, systems) without any filler or 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?

The description conveys the core function but is incomplete for a tool with 6 optional parameters and no output schema. It doesn't clarify what the returned encounter looks like (e.g., full statblocks, names only), how parameters interact, or how it differs from near-sibling rpg_random_encounter. The schema fills parameter details, but the lack of output schema and sibling differentiation leaves gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific semantics beyond what the schema already documents (e.g., it doesn't explain how terrain or monster_type filters work). It relies entirely on the schema for parameter meaning.

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 'Generate' with a clear resource ('tabletop RPG encounter') and specifies output components (CR-appropriate monsters, terrain, loot) plus supported systems (D&D 5e / Pathfinder 1e). This clearly distinguishes it from generic oracle tools like oracle_scene or oracle_ask, and even from rpg_random_encounter which lacks the specificity of CR-appropriate and loot.

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

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

The description states what the tool does, so usage is implied (when you need an encounter). However, it provides no explicit guidance on when to use this tool versus similar siblings like rpg_random_encounter or oracle_scene, nor does it mention any exclusions or alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that it 'follows references and returns expanded results,' which conveys the core behavior, but it does not detail edge cases, recursivity, or how unresolved references are handled. This is adequate but minimal.

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, front-loaded with the main action, and includes a concrete example. Every word 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?

The tool has no output schema, so the description should clarify return values. It only says 'returns expanded results,' which is vague about whether it's a string, list, or other structure. The description is adequate for basic understanding but lacks detail on out-of-scope cases and output format.

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 all parameters have meaningful descriptions. The tool description does not add significant meaning beyond the schema; it does not clarify the role of 'game' or 'source_table' further. 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 ('Resolve') and clearly identifies the resource ('oracle cross-references') with a concrete example ('Action + Theme'). This clearly distinguishes it from sibling oracle tools like oracle_roll or oracle_table_view, which have different functions.

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 when to use the tool: when you have an oracle result that contains cross-references. However, it does not explicitly mention alternatives or when not to use it. It provides clear context but lacks exclusions or direct comparisons to sibling 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 burden of explaining behavior. The verb 'list' and the phrase about availability make it clear this is a read-only, non-mutating operation, and it adds helpful context about what is returned (oracle tables and entity data availability).

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 concise sentence with no wasted words. It front-loads the action and resource: 'List all supported RPG systems'.

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 discovery tool, the description is adequate. It specifies what is listed and the key attributes (oracle tables and entity data availability). No output schema exists, but the description sufficiently scopes the return value.

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 schema is empty. The baseline is 4, and the description adds no parameter semantics because none are 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 clearly states it lists all supported RPG systems and specifies the scope: those with oracle tables and entity data availability. This differentiates it from sibling tools like oracle_list_tables and rpg_list_categories.

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 this is a discovery tool for available RPG systems but does not explicitly state when to use it versus alternatives. It provides context but no exclusions or direct comparisons.

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 must convey behavioral traits. It reveals the conceptual nature of the output ('curated multi-table compositions that produce coherent narrative prompts') and implies a read-only listing operation, but it does not mention return format, ordering, or any side effects. This is adequate but leaves 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?

The description is a single, front-loaded sentence that defines the tool's action and clarifies the nature of the recipes without any redundant filler. Every word contributes to understanding.

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 low-complexity listing tool with one optional, fully-specified parameter and no output schema, the description sufficiently conveys what the tool does and what kind of items it returns. It would benefit from a brief note on the response shape, but the current information is largely sufficient.

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 has 100% description coverage for the single 'game' parameter, explaining it is an optional filter. The description adds no extra parameter-level meaning beyond what the schema already provides; 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?

The description uses a specific verb 'List' and a specific resource 'predefined scene recipes', and further clarifies them as 'curated multi-table compositions that produce coherent narrative prompts'. This clearly distinguishes the tool from sibling listing tools like oracle_list_tables and oracle_list_games.

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 use when the agent needs to enumerate all available scene recipes, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it name alternative tools for different purposes. The usage context is implied 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?

With no annotations provided, the description bears full responsibility for behavioral disclosure. It does not state whether the operation is read-only, what the return format is, or whether the list is dynamic or static. The description only states the action, offering no transparency into side effects or result structure.

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, compact sentence with no filler words. It is appropriately sized for a simple list tool and front-loads the key information: what is listed and for what scope.

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 gives the core action but lacks context about how the returned table list connects to sibling oracle tools (e.g., oracle_roll, oracle_table_view) and does not explain the return value structure, especially since there is no output schema. For a simple tool it is minimally viable, but the lack of integration guidance leaves gaps.

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

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

The schema description covers 100% of the single parameter, providing a baseline of 3. The description adds minimal extra meaning beyond the schema — it mentions 'system' but does not clarify valid values or provide examples. Since schema coverage is high, the lack of additional parameter detail is acceptable but not improved.

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 ('oracle tables') with a clear scope ('for a system'). It distinguishes itself from sibling tools like oracle_list_games and oracle_list_recipes by naming a different object type, and from oracle_table_view by focusing on listing rather than viewing a specific table.

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 is provided on when to use this tool versus alternatives like oracle_table_view (to view a table's data) or oracle_ask (to get an answer from an oracle). There are no exclusions, preconditions, or explicit alternative mentions, leaving the usage context merely implied by the verb and resource.

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 clearly states the action is random ('roll'), implying no state change, but it does not describe what is returned or how errors are handled. The 'random' qualifier is useful but limited; a note about output format would raise this score.

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, front-loaded with the action and resource, and free of any filler. Every word contributes to understanding, making it an excellent example of concise, effective description.

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 tool with no output schema, the description and schema are mostly adequate. However, without annotations or an output schema, the description should mention what a roll returns (e.g., a result phrase, a die result, etc.) to be fully complete. It covers the input side but leaves the output side entirely implicit.

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% for both parameters. The description adds human-readable examples of systems ('Ironsworn, Starforged, Maze Rats') that align with the schema, but this is marginal added value since the schema already lists slugs and the optionality of 'table'.

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 ('Roll') and resource ('random oracle table') and names example systems, clearly distinguishing from sibling tools like oracle_table_view or oracle_list_tables. The purpose is immediately obvious.

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 when a random oracle result is needed, and the 'etc.' hints at multiple systems, but it does not explicitly state when to prefer this tool over alternatives like oracle_ask or oracle_scene. Sibling context helps, but the description itself lacks explicit 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 transparency burden. It explains the core behavior: rolling tables, resolving cross-references, composing a narrative sentence, or selecting random tables. It does not disclose the return format, potential errors, or side effects, but for a generation tool this is a reasonable level of transparency.

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, front-loaded with the main action and concise in covering both usage modes. Every word earns its place; no extraneous 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?

With no output schema, the description should clarify what the tool returns. It implies a narrative sentence but does not state the return type explicitly. It also omits details about how region and system parameters affect recipes. For a moderate-complexity tool, this is adequate but has 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the behavioral implications of the recipe parameter (resolving cross-references, composing a narrative) and clarifying the random mode's default behavior. This contextualizes how the parameters interact.

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 clearly states the tool's purpose: 'Generate a scene using oracle tables.' It specifies the two modes (with recipe and without), which distinguishes it from sibling tools like oracle_roll that handle single rolls. The phrase 'composes a narrative sentence' further differentiates it as a scene generator.

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 context is implied through the two modes ('With a recipe' vs 'Without'), which tells the agent when each mode is applicable. However, there is no explicit guidance on when to choose this tool over siblings like oracle_encounter or oracle_interpret, and no mention of when not to use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool shows all entries with roll ranges, but does not disclose whether this is a read-only operation, any output limits, performance implications, or whether the full table is returned in a single response. This lack of additional context leaves behavioral traits largely 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?

The description is a single, concise sentence that immediately states the tool's purpose and scope. It wastes no words and is front-loaded with 'View the complete contents'.

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

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

Given the tool's low complexity (two parameters, no output schema), the description covers the core functionality well by specifying the exact output (all entries with roll ranges). However, it lacks usage guidance and any behavioral caveats, which keeps it from being fully complete.

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

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

The input schema already provides 100% coverage for both parameters (game and table). The description adds context about the content (all entries with roll ranges) but does not elaborate on parameter-specific meaning or valid values beyond what the schema provides. Baseline of 3 is appropriate for full schema coverage.

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

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

The description clearly states the tool's function: 'View the complete contents of an oracle table — all entries with roll ranges'. The verb 'View' and resource 'oracle table' are specific, and it distinguishes from sibling tools like oracle_roll (which rolls on a table) and oracle_list_tables (which lists available tables).

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 tool is for viewing table contents, but it does not explicitly mention when to use it over alternatives or provide exclusions. Sibling tools like oracle_roll or oracle_list_tables exist, and the description does not contrast with them, leaving the usage context somewhat 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get full details and piece list' without stating that the operation is read-only, what constitutes 'full details', or any error handling or pagination behavior.

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

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

The description is a single concise sentence that front-loads the primary purpose. It contains no redundant words and is efficiently structured.

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 tool with one parameter and no output schema, the description is minimally adequate but lacks specificity about what 'full details' and 'piece list' entail. It does not mention return structure or any limits, making it acceptable but not complete for a tool that may return varied data.

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 single 'set' parameter as 'Set name or ID' with 100% coverage. The description adds little beyond the word 'specific', which reiterates that a particular set must be identified, so it provides minimal additional value.

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 clearly states the action ('Get') and the resource ('full details and piece list for a specific set'), making its purpose unambiguous. It is differentiated from siblings like piece_gallery_search and piece_gallery_stats by focusing on a single set, though it does not explicitly name 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?

No guidance is given on when to use this tool versus alternatives like piece_gallery_search. The phrase 'specific set' implies the user already has a set identifier, but it does not explicitly state prerequisites or provide directions for other use cases.

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 is the sole source of behavioral information. It discloses that the search matches name, style, or game type, but it does not describe result ordering, pagination, return format, or any side effects, leaving significant behavioral gaps.

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

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

The description is a single, concise sentence that immediately states the tool's purpose. It contains 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?

The tool is a search operation with no output schema, so the description should explain what results are returned. It only states the search action and fields, omitting any detail about response structure, sorting, or limits, making it incomplete for agent usage.

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 schema already provides descriptions for all three parameters (100% coverage). The description adds semantic value by clarifying that the query can match across 'name, style, or game type', which is not explicitly stated in the schema's property description.

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 clearly states a specific verb ('Search') and resource ('piece set gallery'), and identifies searchable fields ('by name, style, or game type'). This distinguishes it from sibling search tools like board_gallery_search and tile_gallery_search by specifying the gallery 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 establishes clear context by indicating this tool searches piece sets, which guides when to use it vs other gallery searches. However, it does not explicitly name alternative tools or provide exclusion criteria, so it falls short of a 5.

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

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

With no annotations, the description must carry the transparency burden. It implies a read-only operation ('Get statistics') and enumerates the returned categories, but it does not state explicitly whether the call has side effects, requires auth, or what the output structure looks like. This is adequate for a simple read-only tool 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?

The description is a single, front-loaded sentence that conveys the tool's purpose and key output categories with zero 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-parameter, output-schema-less tool, the description is reasonably complete: it names the resource and expected statistic categories. However, it does not specify the exact response format or whether results are aggregated counts, which would be helpful given the lack of an output 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 tool accepts zero parameters, so the baseline is 4. The description adds value by clarifying what 'statistics' means (sets, styles, authors, game families), which helps the agent understand the output even without parameter explanations.

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 ('Get') and resource ('piece gallery') and lists the exact statistics fields (total sets, styles, authors, game families). This clearly differentiates it from sibling tools like piece_gallery_search or piece_gallery_get_set, which have different purposes.

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 this tool versus similar gallery stats tools (e.g., board_gallery_stats, tile_gallery_stats) or the piece gallery search/get_set tools. The description states only what it does, not when it is the preferred choice.

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

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

With no annotations, the description carries the full burden. It discloses that the tool applies a move and returns a new state, and notes format variability. However, it doesn't mention whether the original state is mutated, error behavior for invalid moves, or any side effects, which are important for a mutation tool.

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

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

Two sentences, front-loaded with the core action and outcome, followed by concise format guidance. No filler or repetition of schema fields, making it very efficient.

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

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

For a simple 2-parameter tool, the description covers the core behavior, return value, and input sources, and gives examples for varying families. It lacks error-handling details but given no output schema, it adequately explains the new state. It is not comprehensive, but sufficient for the tool's complexity.

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

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

Schema coverage is 100%, with both parameters described in the schema including examples. The description adds the constraint 'exactly as returned by play_get_moves' for the move parameter, reinforcing the source, but doesn't significantly augment the schema's meaning for the state parameter. It meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'Apply' and the resource 'a move to the game', with a specific outcome 'return the new state'. It distinguishes itself from siblings like play_get_moves (which retrieves moves) by implying this tool executes a move. The mention of family-specific formats adds specificity.

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 provides clear usage context by instructing to pass the move object 'exactly as returned by play_get_moves', and implies the state comes from play_create_game or previous apply. However, it doesn't explicitly contrast with alternatives like play_make_moves or state when not to use it, so it doesn't fully cover exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses what status information is returned, and the verb 'check' strongly implies a read-only operation, but it does not explicitly state that it has no side effects or describe behavior with invalid/incomplete state.

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

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

The description is a single, focused sentence that front-loads the action and lists the specific status dimensions. There is no filler or 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 simple, single-parameter read-only tool, the description adequately covers the purpose, input source, and result dimensions. It lacks explicit guidance on error cases or alternatives, but these are less critical given the tool's simplicity.

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

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

The input schema already provides full coverage for the single state parameter, including its origin from play_create_game or play_apply_move. The description adds no additional parameter semantics, 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 opens with a specific verb and resource: 'Check the current game status.' It then enumerates exactly what the status includes (whose turn, game over, winner), which clearly distinguishes it from sibling tools like play_get_moves or play_render_board.

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 by referencing game state from play_create_game or play_apply_move in the schema, but it does not explicitly state when to choose this tool over alternatives or mention any exclusions. The intended context is apparent but not spelled out.

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

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

With no annotations, the description carries the full burden. It discloses that this is a creation operation and that it returns initial state, but it does not mention side effects, persistence, or error behavior. It gives some useful behavioral context but leaves room for ambiguity about what 'create' implies server-side.

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 concise sentences: the first states the primary purpose and output, the second clarifies variant formatting with examples. Every sentence earns its place with no filler.

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

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

The description covers the essential workflow for a create tool: what it does, what it returns, and how variants work. Although there is no output schema, it tells the agent that the return value is initial state for subsequent calls, which is sufficient for an agent to proceed. Minor gaps around state persistence and error handling are not critical given the simplicity and sibling context.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds concrete variant examples ('grand+random', 'standard+drops'), which helps clarify the variant parameter beyond the schema's generic description, but it does not add meaning for family or rngSeed beyond what the schema already provides.

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 ('Create') and resource ('game instance for a given family'), clearly distinguishing it from sibling tools like play_apply_move and play_check_status. It also states the key output (initial state), so an agent knows what this tool accomplishes.

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 a workflow: create a new game instance first, then pass the returned initial state to subsequent calls. This is clear enough context for when to use it, though it doesn't explicitly name alternatives or state when not to use 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 present, so the description carries the disclosure burden. It does disclose that this is an export operation (non-mutating), that it returns a string, and that it covers all 10 families. It could mention behavior on invalid or partial game states, but for a read-only conversion utility the main behavioral traits are covered.

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

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

Two short sentences with no filler: the primary action is front-loaded, and the family scope follows immediately. Every word contributes to the agent's understanding.

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

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

For a simple one-parameter, read-only utility with no output schema, the description plus input schema covers the essential contract: input state, output string, and supported families. It could be slightly richer about FEN-format caveats for non-chess families, but nothing critical is missing for a correct call.

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

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

The input schema already documents the only parameter at 100% coverage, including that it is the game state object from play_create_game or play_apply_move. The description adds no additional parameter-level detail beyond 'current board position', which is already implied by the schema.

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

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

States an explicit action ('Export'), a precise resource ('current board position'), and the result ('FEN-style notation string'). The family list and the sibling play_load_fen make it easy to differentiate exporting from loading FEN data.

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 when to use it: when the current board position needs to be exported as a FEN-style string, and it explicitly confirms all 10 families are supported. However, it does not explicitly contrast this with siblings such as play_load_fen or play_render_board, so guidance about alternatives 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 behavioral transparency burden. It clearly signals a read-only lookup through 'Get' and 'Returns', and discloses what the response contains: engine definition, resolved frontmatter, and specific components. It does not discuss errors or invalid variant behavior, but the core behavior is transparent.

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, both informative and waste-free. The main action and resource are front-loaded, followed by a clarifying parenthetical and a concise statement about the return value.

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 appropriately explains what is returned (full engine definition, resolved frontmatter, topology, render config, pieces, setup FEN). It is mostly complete for a config-fetching tool, though it could mention edge cases like invalid family or unknown variant.

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 parameters are already well documented. The description adds general context about 'game variant' but does not provide additional per-parameter meaning, so the baseline score 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?

The description uses a specific verb ('Get') and resource ('full engine definition'), and enumerates the contents (topology, render config, pieces, setup FEN). This clearly distinguishes it from sibling play_* tools that handle moves, status, and game creation.

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 'used to render and play the game' implies when this tool is relevant, but the description does not explicitly state when to use it over alternatives or when not to use it. No exclusions or alternative tool references are provided.

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 only states a prerequisite and the fact that it retrieves legal moves. It does not explicitly say whether the operation is read-only, whether it modifies the state, or what errors might occur. For a 'get' tool, the read-only nature is implied but not stated, and no additional context like return format or side effects is provided.

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, front-loaded with the primary purpose, and includes the essential prerequisite. Every word earns its place; there is no redundancy or irrelevant detail. It is appropriately sized for a simple tool with one parameter.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the input requirement but lacks any information about the return format or the structure of legal moves. It also does not confirm whether the operation is non-mutating. There is no output schema to compensate, so this is a moderate gap, making it minimally viable but not complete.

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

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

The schema fully describes the single parameter 'state' as a game state object returned by play_create_game or play_apply_move, with 100% coverage. The description adds no new meaning beyond repeating the same prerequisite. Baseline 3 applies because 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 clearly states the action ('Get all legal moves') and the resource ('current position'), which is derived from a game state. It mentions the prerequisite of state from play_create_game or play_apply_move, but it does not explicitly differentiate from sibling tools like chess_get_legal_moves, so it falls short of a 5.

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

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

The description implies when to use the tool: after creating a game or applying a move, when you need legal moves. However, it does not mention alternatives, exclusions, or specific scenarios where another tool (e.g., chess_get_legal_moves) would be preferred. Context is given but no explicit 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 burden of behavioral disclosure. It does clarify scope ('all'), content (game family names), and gives an explicit list, which is helpful. However, it does not disclose the return format, whether names are identifiers or display labels, or whether ordering is significant.

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, and the parenthetical enumeration is useful without being verbose. Every element contributes to the agent's understanding; no filler or 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 simple zero-parameter listing tool, the description is nearly complete: it states what is listed, the scope, and gives concrete examples. The only minor omission is exact return-value shape, but the low complexity and clear 'List...' verb make the tool safely callable without it.

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

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

The tool has zero parameters and the empty schema fully captures the parameter surface. With no parameters to document, the description does not need to add parameter-level detail, so the baseline of 4 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-resource pair ('List all playable game families supported by the engine') and enumerates concrete examples. It clearly distinguishes this from sibling variant/list tools by focusing on top-level game families rather than moves, variants, or rules.

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

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

The description gives no guidance on when to prefer this tool over siblings such as play_list_variants, rules_list_games, chess_list_variants, or oracle_list_games. There is no explicit 'use this when...' or 'for X, use...' context, leaving the agent to infer applicability.

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 must disclose behavior itself. It explains that variants are identified by slug, that flags exist, and that they must be requested as 'slug+flag' (e.g., '+random'). This is meaningful behavior beyond a plain 'list variants' statement. It does not describe output structure in detail, but covers the key interactive behavior.

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

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

Three short, dense sentences each earn their place: the first states the core purpose, the second connects the output to the downstream consumer, and the third explains a non-obvious input format. No filler or 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 one-parameter, no-output-schema tool, the description is nearly complete: it defines what is listed, how results are consumed, and how flag variants are requested. It could additionally state the expected return shape, since there is no output schema, but the tool is simple enough that the omission is minor.

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 schema already fully describes the one required parameter, 'family', including an enumerated list of valid families. The description adds little parameter-specific meaning beyond saying variants belong to a family and that flag suffixes are used. Schema coverage is 100%, so 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 states the exact operation ('List available variants') and the resource ('for a game family'), making the tool's purpose immediately clear. It further distinguishes the tool by linking each variant to play_create_game, which separates it from family-listing or game-status 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 when to use the tool: after choosing a game family and before creating a game with play_create_game. It does not explicitly name alternatives or exclusions, but the relationship to play_create_game gives sufficient contextual 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 must carry the behavioral disclosure burden. It does not state whether loading a FEN overwrites existing state, validates input, persists the game, or what the tool returns. 'Works for all 10 families' is the only behavioral claim, and it mostly mirrors the schema's family enum.

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 only two short sentences, with the primary action front-loaded and the family scope stated in a single clause. 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?

For a state-creating tool with no output schema and no annotations, the description is incomplete. It omits the return value or success signal, overwrite behavior, validation errors, and how this tool relates to play_export_fen or play_create_game in a typical workflow.

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 parameter descriptions already define 'fen', 'family', and 'variant'. The description adds no new parameter semantics beyond 'FEN-style', which is also present in the schema.

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

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

The description uses a clear verb and resource: 'Create a game state from a FEN-style position string.' The FEN focus distinguishes it from sibling tools like play_create_game and aligns with the reverse operation play_export_fen, though it does not explicitly name or contrast those siblings.

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 usage is implied: when you have a FEN-style position string and want to create a game state from it, use this tool. 'Works for all 10 families' adds scope context, but there is no explicit when-not-to-use guidance or comparison with alternatives such as play_create_game or play_apply_move.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds important traits: 'Stops at the first illegal move' and 'Move objects must match play_get_moves format'. It also indicates the return value is the final state, though it does not clarify whether an illegal move results in an error or a partial state.

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

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

The description is three tight sentences: the primary action, the stopping behavior, and the move format constraint. Every sentence adds value, is front-loaded with the main purpose, and contains no filler or 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?

Given the tool's moderate complexity, no output schema, and no annotations, the description covers the essential points: it returns the final state, stops at illegal moves, and specifies move format. Minor gaps include not describing the behavior with an empty moves array or whether the input state is mutated, but overall it is sufficiently complete for agent use.

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% with descriptions for both parameters, so the baseline is 3. The description mostly repeats the schema's parameter details, such as the move format, and does not add new parameter-level meaning beyond the schema. The 'Stops at the first illegal move' is behavioral and not parameter-specific.

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 clearly states the tool applies a sequence of moves and returns the final state, using a specific verb and resource. It also distinguishes itself from the single-move sibling play_apply_move by explicitly mentioning 'sequence of moves', and the reference to play_get_moves format ties it to the play_* family.

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 clear context that this tool is for applying multiple moves at once and stops on illegal moves, implying it is for batch operations. However, it does not explicitly name alternatives like play_apply_move for a single move or play_validate_move for pre-checking legality, so it lacks explicit when-not-to-use 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 transparency burden. It states SVG output, but the input schema's size parameter says 'for PNG output', creating an unresolved format conflict. The description also fails to disclose what the return value actually is (SVG string, URL, file), how highlights affect the render, or whether the operation is read-only. This leaves an agent uncertain about the tool's behavior.

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

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

The description is a single sentence that front-loads the action and scope. Every word is informative; the family list is long but necessary to convey breadth. No filler, no repetition of schema details.

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

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

There is no output schema and no annotations, so the description must explain the return format and key usage details. It does not resolve the SVG-vs-PNG ambiguity, does not describe the output payload, and gives no guidance on how to obtain a valid state object beyond the schema's pointer. This is a significant completeness gap for a rendering tool that will be invoked across many game families.

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 parameter descriptions are genuinely informative: state is tied to play_create_game/play_apply_move, size includes default/max and a PNG-output hint, and highlights has a concrete example. The description itself adds nothing beyond the schema, so the baseline of 3 is appropriate, though the PNG hint in size conflicts slightly with the SVG claim in the description.

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 ('Render'), a clear resource ('current board position'), and an output format ('SVG'), then enumerates the supported game families. This distinguishes it from specialized siblings like chess_render_svg or hex_export_svg by making its broad cross-game scope 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?

The phrase 'for any playable family' followed by the explicit list gives a clear usage context: this is the generic board renderer for those games. However, it never mentions specialized alternatives like chess_render_svg or hex_export_svg, nor does it state when an agent should choose those instead. The guidance is implied rather than explicit.

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

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

The description discloses the core advisory behavior: the tool analyzes and suggests, and it supports configurable difficulty levels. However, with no annotations provided, there is no explicit statement about read-only status, determinism, rate limits, or output behavior beyond the suggestion itself.

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 short, front-loaded sentences with no filler. The first sentence states the action, and the second adds useful scope and feature information without repeating schema details.

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's purpose, scope, and parameters are adequately clear, but there is no output schema and no mention of the return shape or whether the suggested move can be fed directly into play_apply_move. Given the lack of annotations, this leaves a meaningful integration gap for the 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 coverage is 100%: both state and difficulty are already documented in the input schema, including the enum values and default. The description adds no parameter-level meaning beyond reinforcing that difficulty levels exist, so no uplift above the baseline is warranted.

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 clearly states a specific action ('analyse the position and suggest the best move') and a specific resource scope ('all 10 playable families'). This distinguishes it from move-executing siblings like play_apply_move and from chess-only tools like chess_analyze_position.

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 opening phrase implicitly instructs when to use the tool: when the agent wants an AI-suggested move rather than a move execution or validation. The scope 'all 10 playable families' gives clear context, but no alternatives are explicitly named and no when-not-to-use guidance is provided.

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

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

No annotations are present, so the description carries the burden. It discloses the key non-mutating behavior ('without applying it') and clarifies input format. It does not describe return values or error behavior, but for a read-only validation tool the core side-effect is adequately 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?

Two concise sentences carrying exact information: purpose, side-effect, and input format. No redundant words 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 simple validation tool with two documented parameters, the description is nearly complete. It covers the purpose, non-mutation, and expected move format. A minor gap is the absence of return value description since no output schema exists, but this is not critical for understanding the tool's function.

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%, with both parameters described in the schema. The description's note about the move format duplicates schema text, adding no new semantic value. Baseline 3 is appropriate given high schema coverage.

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

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

Description clearly states the tool checks move legality without applying it, using specific verb+object ('check whether a move is legal'). It distinguishes itself from apply-like tools by explicitly noting 'without applying it' and references the matching format from play_get_moves.

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 clear context: use for validating a move before applying it, with the move object from play_get_moves. It does not explicitly name alternative tools or exclusion cases, but the 'without applying it' implies when not to use apply-move 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?

No annotations are provided, and the description carries the full burden. It does not disclose whether the operation is deterministic or volatile, what the return value format is, or any side effects. The word 'Randomise' implies a random operation, but the description lacks basic behavioral details such as 'returns a new list'.

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

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

One short sentence, no fluff, front-loaded verb and resource. 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 with only one input parameter and no output schema. However, the description does not explicitly state the return value (e.g., the list of players in random order). While inferable, this gap prevents a higher score.

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% (the only parameter 'players' is described as 'Player names'). The description adds no extra meaning beyond that, but the parameter is straightforward enough that the schema suffices. 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 ('Randomise') and resource ('turn order') with a clear scope ('for a list of players'). It distinguishes itself from sibling tools like team_split or dice_roll by clearly stating its function.

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 alternatives are mentioned, but the purpose implies the use case: randomize the order of players in a game. Since there are no competing sibling tools for this exact function, the usage is implied rather than clearly 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?

With no annotations at all, the description must disclose behavioral traits, but it only says 'browse' and 'pagination.' It does not explicitly confirm read-only safety, response format, side effects, or any required context like the 'system' parameter. The behavioral surface beyond the schema is nearly empty.

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 one concise, front-loaded sentence with no filler. It is efficient, though it could have used a second sentence to add valuable context like response format or usage guidance without becoming verbose.

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

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

Even for a relatively simple browse tool, the description is insufficient. There is no output schema, so the agent has no idea what the response contains, and the description does not mention required system context, entity types, or how pagination manifests. This leaves too much to be inferred from the parameter names.

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%, with clear descriptions for all five parameters (including defaults and the 'game' alias for 'system'). The description adds no additional parameter meaning beyond naming 'category' and 'pagination,' so the baseline score 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 states a specific verb ('Browse') on a resource ('entities') with a defined scope ('by category with pagination'). This clearly differentiates it from siblings like rpg_search_entities (query-based search) and rpg_get_entity (single entity retrieval), even though those alternatives aren't explicitly named.

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 no explicit guidance on when to use this tool versus the many related siblings (e.g., rpg_search_entities, rpg_list_categories, rpg_get_entity). The phrase 'by category' weakly implies a use case, but it does not state exclusions or recommend alternatives, so the agent must infer usage 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?

No annotations are provided, so the description carries full responsibility. It states the basic generation action but does not disclose output format, error behavior with invalid systems, or any limitations/quirks. This is minimal transparency.

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 immediately states the tool's function and gives useful examples. No redundant words 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?

Even for a relatively simple generator, the description is thin. It does not mention what the output looks like (e.g., JSON character sheet, stats), how level/class interact with system, or any default behavior beyond what the schema hints. With no output schema, this is a notable 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 descriptions for system, class, and level. The description adds little beyond listing a few example systems, which are already enumerated in the schema, so it doesn't enhance parameter understanding.

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 ('Generate') and resource ('random character for an RPG system'), and lists concrete systems, making the tool's purpose explicit and distinct from sibling tools like rpg_loot or rpg_random_encounter.

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 guidance on when to use this tool versus alternatives. With siblings like rpg_random and rpg_random_encounter, the description should clarify that this is for character generation specifically, but it does not.

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

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

With no annotations, the description carries the full burden. 'Get full details' implies a read operation, but it does not disclose how optional parameters (system, category) affect behavior, what happens if the entity is not found, or any response characteristics. The description is too minimal to provide meaningful behavioral transparency.

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, clear sentence with no redundancy or filler. It is front-loaded with the action and resource, making it easy to skim. Perfectly concise for a simple lookup 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?

The tool has 4 parameters (one required) and no output schema. The description does not explain how optional filters (system, category) interact with the name lookup, nor does it reference sibling search tools for alternative usage. For a get tool, it is adequate but leaves ambiguity around filtering and return format.

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. The description adds only 'by name', which is redundant with the name parameter description. No additional semantic context is provided beyond what the schema offers.

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 ('get') and resource ('full details of a specific RPG entity') with a clear method ('by name'), distinguishing it from sibling tools like rpg_search_entities which would be for finding entities without knowing the exact name.

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 for exact-name lookups but does not explicitly state when to use this vs. alternatives such as rpg_search_entities or rpg_browse_category. No when-not-to-use guidance is provided.

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 provided, the description carries the full burden. It states the tool lists categories, which is a read-only operation implied by the verb 'List'. However, it does not disclose any details about response format, potential default behavior when 'game' is omitted, or any limits. For a simple list operation, this is adequate but not thorough.