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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not explain what the search returns, whether it is read-only, or any limitations. It only states the scope of the gallery, not the tool's behavior beyond 'search'.

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-loading the core verb and resource. It includes only useful information (the count and scope) without any fluff, making it efficient 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 has no output schema, so the description should explain what the search returns. It does not. It also lacks details about default behavior, such as sorting or filtering beyond the query. While the tool is simple, the description leaves too much unspecified for an agent to fully understand the tool's behavior.

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 covers both parameters with clear descriptions (limit, query), so the description need not add much. The description adds no extra parameter information beyond what the schema provides, but the high schema coverage earns a 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: 'Search the board gallery' with a specific resource and verb. It also adds useful context about the content (333 rendered board layouts across 33 game families), which distinguishes it from similar sibling tools like piece_gallery_search and 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 implies usage when the agent needs to search for board layouts, but it does not explicitly mention when to use this tool over alternatives like board_gallery_get or board_gallery_stats. The inclusion of the gallery contents provides context for what it searches, but no direct 'when' or 'when not' guidance.

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

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

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 burden. It discloses the random behavior and filtering, but lacks details about the pool, return format, or side effects. For a read-only 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?

Two concise sentences with no unnecessary words. The key information is front-loaded: the action and the filter options.

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, the description is functional, but it omits the output structure (e.g., FEN, solution) and the nature of the puzzle pool, which the agent might need to know. No output schema increases the need for such detail.

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 describes both parameters. The description only repeats 'difficulty or theme' as filters, adding negligible semantic value 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 states the action (Get a random chess puzzle) and the resource (puzzle from pool), with filtering options. It distinguishes from sibling tools like chess_list_puzzle_types or chess_get_opening_book by focusing on random puzzle generation.

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 puzzle is needed, with optional filtering. It provides clear context but does not explicitly mention alternatives or when not to use this tool.

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

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

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?

With no annotations, the description carries the burden of disclosure. It conveys that the tool performs a read-only listing operation and specifies the data source, but it does not describe the return format, any filtering behavior, or potential side effects. This is sufficient for a simple list tool but lacks richer contextual detail.

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 is free of redundant words and directly communicates the tool's 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?

Given the tool's simplicity (no parameters, no output schema), the description provides sufficient information for an agent to select and invoke it correctly. The reference to 'puzzle pool' adds helpful context, though a bit more detail about return values would make it 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 tool has zero parameters, so the baseline is 4. The description adds no parameter-specific details, but none are needed. The empty schema is already fully covered.

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 ('List'), the resource ('puzzle variants and themes'), and the source ('puzzle pool'). It distinguishes itself from sibling tools like chess_list_variants by explicitly referencing puzzle-specific content.

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 clear use case: when an agent needs to know available puzzle types or themes, this tool should be called. While it doesn't explicitly mention alternatives, the context is straightforward and no exclusions are needed.

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 provided, the description must carry the full burden. It discloses that the tool creates a game instance and returns initial state, but does not mention persistence, authentication, rate limits, or the exact structure of the returned state. This is adequate but not deeply 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?

The description is two sentences, with the first stating the core purpose and the second explaining the key return value. It is appropriately sized and front-loaded, with no redundant content.

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 tool with no output schema, the description covers the essential purpose and return semantics ('initial state' for subsequent calls). It could be more specific about which subsequent calls expect this state, but overall it is sufficient for the tool's simplicity.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema. The description adds little beyond mentioning 'given family' and the return of initial state, which is consistent with the baseline for high 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 uses a specific verb and resource ('Create a new game instance') and adds scope ('for a given family'), distinguishing it from sibling play_* tools that operate on existing games. The mention of returning initial state further clarifies its role as a creation/initialization tool.

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

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

The description indicates when to use the tool by noting it 'Returns initial state to pass to subsequent calls,' establishing this as the entry point for game play. It does not explicitly name alternatives or exclusions, but the context is clear and the flow is 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?

No annotations are provided, so the description carries the burden. 'Export' strongly implies a read-only operation, and 'FEN-style' signals a non-standard notation, but it does not explicitly state that the state is not mutated, nor does it describe error behavior for invalid state. The description adds some nuance (support for all families) but lacks explicit behavioral disclosure.

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

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

Two concise sentences: the first states the action and output, and the second adds the scope of all six families. No redundant words or filler, every clause earns its place.

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

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

The tool has one simple parameter, no annotations, and no output schema, but the description adequately covers the purpose, the return format, and the supported families. It does not mention edge cases or error handling, but for a simple export operation this is complete enough. Slight deduction for not explicitly linking to play_load_fen.

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 coverage is 100% and the parameter 'state' is already described as 'Game state object from play_create_game or play_apply_move', which fully clarifies its semantics. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Export') and resource ('current board position'), specifies the output format ('FEN-style notation string'), and explicitly notes it applies to all 6 game families. This clearly distinguishes it from siblings like play_load_fen (opposite direction) and play_render_board (visual output).

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 you need a serialized board position and clarifies broad family support, but it does not explicitly state when to use this versus alternatives or mention that play_load_fen can consume the output. There is no exclusion guidance, so it stays at 'implied usage'.

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

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

With no annotations, the description carries the full burden. It explicitly states it 'Returns the resolved frontmatter' and lists the components, making the read-only, non-mutating nature clear. It does not cover error conditions or performance, but for a simple retrieval tool this is adequate.

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

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

The description is only two sentences, front-loads the action, and each clause provides relevant information about the output and its purpose. There is no wasted or redundant 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?

Given the lack of an output schema, the description gives a solid outline of the return value (topology, render config, pieces, setup FEN) and its role. It is sufficient for a 2-parameter, read-only retrieval, though it could briefly mention how to find valid variant slugs.

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 'family' and 'variant' fully described. The description adds no parameter-specific semantics beyond mentioning 'game variant', so it does not exceed the schema baseline.

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

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

The description uses a specific verb ('Get') with a specific resource ('full engine definition') and scope ('for a game variant'), enumerating the contents (topology, render config, pieces, setup FEN). This clearly distinguishes it from sibling tools like play_get_moves or play_list_variants.

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 by stating the returned definition is 'used to render and play the game,' indicating a prerequisite role. However, it does not explicitly mention alternatives or exclusions, such as using play_list_variants to discover available variant slugs.

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?

With no annotations, the description carries the burden of behavioral disclosure. 'List all' implies a read-only, exhaustive operation with no side effects, and the example families give concrete expectations. However, it does not detail the return format or any potential limitations (e.g., pagination), though for a small fixed set this is minor.

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 unnecessary words or repetition. It front-loads the main action and includes examples for clarity.

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

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

For a simple no-parameter listing tool with no output schema, the description is nearly complete: it names the resource, scope, and examples. It could explicitly mention the return value (e.g., 'returns an array of family names'), but the behavior is still unambiguous. A score of 4 reflects this minor gap.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description adds no parameter-specific details, but 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 the tool's purpose: 'List all playable game families supported by the engine' with specific examples (chess, draughts, go, reversi, shogi, xiangqi). This is a specific verb+resource combination that distinguishes it from sibling tools like rules_list_games or play_list_variants.

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 you need to know which game families are playable, but it does not explicitly state when to use this versus alternatives. No exclusions or comparisons to other list tools are provided, so guidance is implicit 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?

With no annotations provided, the description carries the burden of disclosing behavior. It clearly implies a read-only listing operation, which is inherently non-destructive, but it does not explicitly state how invalid families are handled or the exact return format. The added note about passing variants to play_create_game provides some behavioral context, but not comprehensive 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 primary purpose, and includes a practical downstream-usage note. It contains no fluff or redundant information.

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

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

The tool is simple (one parameter, no output schema), and the description covers what it does and how the result is used. It does not detail the response structure, but for a list operation that returns variant names, this is sufficient. The sibling context and the explicit link to play_create_game round out the usability.

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 does not add semantic detail about the 'family' parameter beyond what the schema already provides; its second sentence refers to the output rather than the input parameter. Thus, no additional value is contributed.

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 ('available variants for a game family'), clearly stating the tool's function. It distinguishes itself from siblings like chess_list_variants by focusing on game families generally, and ties its output to play_create_game.

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

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

The description provides clear context by stating that each variant can be passed to play_create_game, indicating when this tool is useful (before game creation). It does not explicitly mention alternatives or exclusions, but the connection to a sibling tool is a strong usage hint.

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 provides minimal behavioral detail. It does not state whether a game ID is returned, whether the game persists, what happens on invalid FEN, or any side effects. The phrase 'game state' is vague.

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, front-loaded with the action. Every word earns its place, with no redundancy or 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 no output schema, the description should explain what the caller receives (e.g., a game ID). It also omits error handling and variant behavior. While the scope is clear, significant gaps remain.

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 covers parameters at 100%. The description adds value by confirming the family parameter spans all 6 families and by reinforcing the FEN-style notation, though it does not detail variant semantics.

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

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

The description defines a specific action (create a game state) on a specific resource (FEN-style position string) and adds scope (works for all 6 families), clearly distinguishing it from reverse or alternative tools like play_export_fen.

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

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

It states the tool works across all 6 families, indicating it is the general-purpose FEN loader. However, it does not explicitly mention when not to use it or compare it to alternatives like play_create_game or play_export_fen.

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 exist, so the description carries the disclosure burden. It states output as SVG, but the schema's size parameter is described as 'for PNG output,' creating an unresolved ambiguity. It also doesn't explain behavior for invalid states, unsupported families, or whether highlights alter the rendering.

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, no filler, front-loads the core action, output format, and scope. It is compact and scannable.

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

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

With no output schema and no annotations, the description needs to explain return format and behavior; it only gives a high-level promise. The SVG/PNG discrepancy and lack of error/edge-case information make it insufficient 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?

All three parameters have schema descriptions, so the baseline is 3. The description adds no extra parameter-specific details beyond mentioning 'current board position,' which maps to the state parameter.

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

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

The description uses a specific verb ('Render'), identifies the resource ('current board position'), and specifies output format ('SVG') plus supported game families, distinguishing it from chess-specific renderers like chess_render_svg and hex map renderers.

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

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

It implies generic use across multiple game families but doesn't explicitly state when to choose this over sibling tools (e.g., chess_render_svg) or mention exclusions. The phrase 'for any playable family' provides context but no direct 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 does not disclose whether the operation is read-only, whether it modifies the game state, what side effects it may have, or what the output format looks like. The mention of 'Supports 5 difficulty levels' is a behavioral trait, but key transparency details are missing.

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, no filler. The purpose is front-loaded, and the additional sentence about difficulty levels and families is informative. 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 has two parameters, a nested object, and no output schema, yet the description is minimal. It fails to explain return values, error behavior, or how the response should be interpreted. While the state parameter schema references play_create_game/play_apply_move, the description does not elaborate on prerequisites or output structure, making it incomplete for real-world invocation.

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

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

Schema description coverage is 100%, so the schema documents both parameters (state and difficulty). The description adds 'Supports 5 difficulty levels' which aligns with the difficulty enum, but it does not add meaningful semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('suggest the best move') and clearly identifies the resource (AI analysis of the position). It distinguishes itself from sibling tools by mentioning 'across all 6 playable families,' though it does not explicitly name an alternative 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 description implies usage when you need an AI-suggested move, but it provides no explicit 'when not to use' or alternatives. It does not contrast with sibling tools like play_get_moves or chess_analyze_position, leaving the agent to infer the appropriate context.

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

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

No annotations are 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?

No annotations are provided. The description adds pagination behavior but lacks detail on ordering, handling of invalid categories, or read-only safety. Minimal behavioral context beyond the schema.

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

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

A single sentence that front-loads the purpose and scope with zero wasted words. Highly concise and clear.

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 browse tool with fully documented parameters, the description adequately conveys intent and pagination. No output schema exists, but the return value is implied as a list of browsed entities; more detail would be helpful but is not critical.

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 covers all 4 parameters with descriptions, so baseline is 3. The description adds no further meaning beyond the category and pagination concepts already 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 'Browse entities by category with pagination' clearly states a specific verb and resource, distinguishing it from siblings like rpg_search_entities and rpg_get_entity.

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 paginated category browsing but provides no explicit when-to-use guidance or alternatives. It does not mention exclusions or contrast with 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?

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 provided, the description alone must disclose behavioral traits. It only states 'full details' without mentioning error handling (e.g., entity not found), return format, or whether the optional 'system' parameter affects behavior. This is minimal disclosure for a simple read 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 that conveys the core action immediately. Every word earns its place, with no redundancy or 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?

For a simple get-by-name tool with two parameters and no output schema, the description is minimally viable. However, it doesn't explain what 'full details' encompasses, how the optional 'system' parameter factors in, or what happens on failure, leaving some gaps in 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 description coverage is 100% (both 'name' and 'system' have descriptions), so the baseline is 3. The description reinforces the 'name' parameter but adds no extra meaning for 'system' beyond the schema's vague 'System slug'.

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 scope ('by name') that clearly distinguishes it from sibling tools like rpg_search_entities or rpg_browse_category. It leaves no ambiguity about what the tool does.

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 name' implies this tool is for fetching a known entity, but it doesn't explicitly state when to use this over alternatives like rpg_search_entities or what to do when the name is unknown. Some usage context is conveyed, but without exclusions or specific alternatives, guidance is only implicit.

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