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

No annotations exist, so description must cover behavioral traits. It mentions reading files directly and being offline, but lacks details about error handling, performance, or side effects. Basic functionality is stated, but not comprehensive.

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 action and result. Every sentence provides value: first sentence defines purpose and output, second adds behavioral context. 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?

Low complexity (1 param, simple output), but no output schema exists. Description hints at return values (scripts, functions, numeric defines) but doesn't specify format or structure. Incomplete for an agent to interpret results.

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?

Only one parameter 'dir' with 0% schema description coverage. Description does not explain what 'dir' should be (path format, required/optional, default). Completely lacking parameter 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?

Description states it parses .acs files to return symbol counts (scripts, functions, numeric defines). Verb 'parse' and resource 'directory of .acs source files' are clear. However, it doesn't explicitly differentiate from siblings like find_acs_symbol, but the purpose is specific.

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?

Only implicit guidance: 'Reads files directly; no game needed' suggests offline use, but no explicit when to use vs alternatives or exclusions. No mention of prerequisites or situations to avoid.

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 convey behavioral traits. It specifies the returned data but does not disclose whether the operation is read-only, expensive, or requires a running game. Minimal behavioral context beyond output fields.

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 conveys the core purpose and output details without unnecessary words. Highly concise and structured for quick comprehension.

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 two optional parameters and no output schema, the description covers the main functionality and radius default. It lacks details about the 'instance' parameter, error handling, or empty results, but overall it is 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?

Schema description coverage is 0%. The description explains the 'radius' parameter (map units, default 512) but does not address the 'instance' parameter. Thus, it partially compensates for the schema 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 runs 'actorsnear' and returns actors within a radius of the player, listing specific fields (class, health, position, current sprite). It distinguishes itself from sibling tools like 'inspect_target' (single actor) and 'player_state' (player-only).

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies a usage context (near player) but does not mention alternatives or exclusions, leaving the agent to infer.

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 bears full responsibility. It lists what the tool returns but does not state whether it has side effects or is read-only. The action 'run dumpactor' suggests inspection, but the behavioral safety profile is not explicitly communicated. Given the potential for misuse (e.g., actor state mutation?), this omission is notable.

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: two sentences deliver purpose, output detail, default behavior, and targeting syntax. No word is wasted, and the most critical information is front-loaded. Excellent structure.

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 provides a comprehensive list of returned fields (class, health, position, DECORATE state, inventory, ready weapon, morph status). It includes an example of the DECORATE format. However, it does not explain how to interpret all fields or mention potential errors. For a debug tool of this complexity, it is mostly complete.

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

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

Schema coverage is 0%, so the description must explain parameters. It partially addresses 'tid': mentions defaulting to player (TID=0) and passing a TID for any actor. However, it completely ignores the 'instance' parameter, leaving its purpose unclear. A tool with two parameters should describe both.

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 ('run dumpactor and return an actor's live state') and enumerates specific output fields (class, health, position, DECORATE state, inventory, etc.). It also notes the default behavior (player) and how to target other actors via TID. However, it does not explicitly differentiate from sibling tools like 'player_state' or 'inspect_target', which could cause confusion.

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 basic guidance: defaults to player and accepts a TID for other actors. However, it lacks explicit 'when to use' versus alternatives, such as distinguishing from 'player_state' for player-specific data or 'inspect_target' for a different view. No exclusions or prerequisites are mentioned.

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 disclosing behavior. It explains the connection to an already running engine, the binding to an instance number for other tools, and the default port behavior. It also mentions the prerequisite 'bridge-patched Zandronum' but does not describe error cases or side effects, which keeps it from a perfect 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 three concise sentences, each adding distinct information: action, usage condition, and default behavior. No redundant or filler 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 tool with only two parameters and no output schema, the description provides sufficient context: purpose, usage condition, alternative tool, and default port. It could mention failure modes but is otherwise complete for its 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 schema provides no descriptions (0% coverage), so the description must compensate. It explains the instance parameter as 'bind it to an instance number for the other tools' and notes port 'Defaults to this instance's conventional port,' adding meaning beyond the bare schema types.

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 'Connect' and clarifies the resource: a bridge-patched Zandronum already running. It explicitly distinguishes from launch_instance by stating 'launch_instance binds automatically,' making its purpose 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?

It explicitly states when this tool is needed: 'Only needed for engines this session didn't launch: launch_instance binds automatically.' This provides a clear conditional for use and names the alternative tool, satisfying the when-to-use vs alternatives requirement.

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

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

No annotations provided, so the description carries full burden. It discloses that the tool reads from compiled ACS lumps, that it only returns names for functions and named scripts (not numbered scripts), and that it's intended for source-less mods. While it doesn't mention error handling or side effects, the read-only nature is implied and the description 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 two sentences long, front-loaded with the verb and resource, and contains no extraneous information. It efficiently conveys the tool's purpose and limitations.

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 (one parameter, no output schema, no annotations), the description is fairly complete. It covers purpose, usage scenario, limitation, and alternative. However, it lacks details on return format and error conditions, but these are somewhat mitigated by 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 0%. The description does not explicitly describe the 'file' parameter, its format, or accepted values. While the context implies the file is a path to a WAD/PK3, this is not directly stated, leaving ambiguity for an AI agent.

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 reads function and named-script names from compiled ACS in WAD/PK3 files, specifically for source-less mods. It distinguishes itself from sibling tools like find_acs_symbol by noting the limitation for numbered scripts.

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

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

The description explicitly states when to use (for source-less mods) and when not to (numbered scripts), and directs users to find_acs_symbol for numbered scripts with source. This provides clear usage guidance and 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. It discloses the transformation and output fields (name, number, file:line) but omits failure behavior, prerequisites, and the role of the optional dir parameter. The 'symbol(s)' hint is vague about multiple results.

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

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

Two concise sentences front-load the core action and resource. The profiler example is illustrative without unnecessary detail, making it 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 simple two-parameter tool with no output schema, the description covers the essential purpose, ref interpretation, and output shape. However, the unexplained dir parameter and lack of error behavior prevent a perfect completeness 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?

The schema has 0% description coverage, so the description must compensate. It explains that ref accepts a script number or name, but the optional dir parameter is completely unexplained. This partial explanation yields a mid-range score.

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 identifies the resource (script number or name to symbol(s)) with clear output fields. The profiler example distinguishes it from sibling list tools like list_scripts and list_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 example 'Turns a profiler script 1017 into a source location' provides a clear use case. It establishes context for when the tool is appropriate but does not explicitly name alternatives or exclusions, so it falls just 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?

The description indicates a read-only operation ('Return') and the core behavior, but it does not disclose details about the optional `file` parameter, return format, or error handling. With no annotations, more transparency would be beneficial, but the description is not contradictory and covers the essential behavior.

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

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

The description is a single, concise sentence that front-loads the action, includes a necessary technical nuance, and contains no 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 has 3 parameters, no output schema, and no annotations. The description covers the primary purpose but omits the role of the `file` parameter and the exact return value representation, leaving an AI agent without enough context to invoke the tool correctly in all scenarios.

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 valuable meaning to the `tag` parameter by explaining the binary tag vs UDMF id distinction. However, it does not explain the `map` or `file` parameters, and schema description coverage is 0%, so the description only partially compensates for the lack of schema descriptions.

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 'Return all sectors whose tag/id matches' and includes the specific distinction between binary `tag` and UDMF `id`, which precisely identifies the tool's function and differentiates it from sibling tools like get_sector that likely operate by sector index.

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

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

Usage is implied by the tool name and description (search by tag/id), but there is no explicit guidance about when to use this tool versus alternatives such as get_sector or when not to use it. The description does not mention any exclusions or prerequisites.

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

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

No annotations are present, so the description must carry the behavioral disclosure burden. It says 'Read' which implies a non-mutating operation, but it does not disclose the return type, error behavior for invalid indices, or the role of the 'instance' parameter. This is minimal and adds little beyond the tool 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 concise sentence (10 words) with no filler. It is front-loaded and directly states the action and resource, earning every word.

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 three parameters, no output schema, and no annotations, this description is under-specified. It does not explain what is returned, invalid-index behavior, or how 'instance' affects the operation, leaving significant gaps for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'world or global' (mirroring the enum) and 'by index' (the parameter name), but it doesn't explain what index refers to, the difference between world and global, or the meaning of 'instance.' The description adds no semantic value beyond what the schema already provides.

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

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

The description clearly states the tool reads an ACS variable specifically by scope ('world or global') and index. This distinguishes it from siblings like set_acs_var (write), list_acs_vars (list all), and find_acs_symbol (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 verb 'Read' implies when to use it, but there are no explicit exclusions or alternative tool recommendations. It doesn't say 'use set_acs_var to modify' or 'use list_acs_vars to enumerate variables.'

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 description carries full burden. It discloses that the tool returns crash data from the last crash, and is empty if no crash occurred. It implies read-only behavior but does not explicitly state if calling is safe or has side effects. 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?

Two concise sentences: first states what it returns, second provides usage context and edge case. No filler, front-loaded with key 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 (one parameter, no output schema), the description covers return values, usage scenario, and empty state. No additional details needed for a tool of this 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 single parameter 'instance' is not explained in the description. Schema coverage is 0% (since description doesn't mention it). The schema defines it as integer with default 1, but lack of description adds no clarity on its role (e.g., which instance, index).

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 specifies the return values (signal, faulting address, symbolized backtrace) and the resource (bridge's crash handler). It clearly distinguishes from sibling tools which do not relate to crash retrieval.

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?

Explicit use case: 'Use this when an instance dies unexpectedly — e.g. run_command reports the bridge closed.' Also mentions empty result if not crashed. No explicit alternatives, but no other sibling tool serves this purpose.

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

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

No annotations are present, so the description carries the full burden. It discloses a useful behavioral trait (sidedef resolution), but omits any error behavior, side effects, or dependencies beyond a simple getter. The single sentence provides the minimum viable 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, focused sentence that front-loads the core action and includes a meaningful qualifier about sidedefs. No wasted words or redundant structure.

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 and no annotations, the description should explain the return shape more fully and clarify all parameters. It mentions the resolved sidedefs but does not describe the exact return structure, the meaning of 'map' versus 'file', or any edge cases. For a tool with three parameters, this is incomplete.

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 clarifies the 'index' parameter ('by index'), leaving 'map' and 'file' unexplained. The optional 'file' parameter is particularly underspecified, meaning the description adds little over the bare schema.

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

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

The description uses a specific verb 'Return' with a direct resource 'one linedef by index', and adds the distinguishing detail that referenced sidedefs are resolved with textures and offsets. This clearly differentiates it from sibling getters like get_sector or find_sectors_by_tag.

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 does not state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It simply describes the action without contextual guidance, leaving the agent to infer usage from the name and parameters.

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 convey behavior. It clarifies this is a read operation (non-destructive) and scopes it to map-level ACS arrays. However, it does not disclose error handling (e.g., out-of-range index), return format, or behavior for missing arrays, which are left unspecified.

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 key parameters. No unnecessary words or clutter.

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

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

For a simple read tool, it gives the core purpose but lacks parameter details (instance) and return behavior. With no output schema or annotations, the description is minimally adequate but leaves some gaps for an AI agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly mentions 'name' and 'index', covering two of three parameters, but does not explain 'instance' or any parameter semantics beyond what the schema names. This is partial compensation.

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 ('Read') and resource ('map-scope ACS array element') and clearly identifies the parameters ('by name and index'). This distinguishes it from sibling tools like get_acs_var (likely scalar) and set_map_array (write operation).

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 reading a single array element but does not explicitly contrast with alternatives such as get_acs_var or list_acs_vars. There are no exclusions or when-not-to-use instructions, but the purpose is fairly clear from the wording.

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 fully disclose behavioral traits. It only states it is a read operation (safe, non-destructive) and mentions cross-module search, but lacks details on return format, error handling (e.g., variable not found), performance implications, or permissions. This leaves significant gaps for an agent.

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 purpose. It contains no filler. However, it could be slightly expanded to include parameter or behavioral hints 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 tool has 2 parameters, no output schema, no annotations, and many sibling tools, the description is minimal. It covers purpose but leaves out usage guidelines, parameter semantics, return behavior, and error scenarios. An agent would need to infer or experiment 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 0%, so the description must compensate. However, it provides no explanation for the 'name' parameter (e.g., format, case sensitivity) or the 'instance' parameter (e.g., meaning, default behavior). The description adds zero value beyond the schema's raw type and requirement constraints.

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 'Read' and identifies the resource as 'map-scope ACS variable', adding the search scope 'searched across loaded modules'. This clearly distinguishes it from sibling tools like 'get_acs_var' (which likely handles other scopes) and 'set_map_var' (write operation).

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 such as 'get_acs_var', 'list_acs_vars', or 'find_acs_symbol'. The description does not mention prerequisites, when-not-to-use, or how this tool fits in a workflow.

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 full behavioral disclosure. 'Return' implies a read-only operation, and 'all fields, format-native keys' adds a useful detail about the output format. However, it does not mention error conditions (e.g., invalid index), prerequisites like a loaded map, or the role of the optional 'file' parameter, leaving transparency incomplete.

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 redundancy or filler. Every word contributes meaning, and it captures the core operation and a key output detail efficiently.

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 three parameters, no output schema, and no annotations, the description is too sparse to be complete. It does not explain the 'map' and 'file' parameters, lacks any usage guidance relative to siblings, and provides no error or prerequisite context, making it only minimally adequate for an agent to invoke the tool confidently.

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 0% description coverage, so the description must compensate for parameter meaning. The only parameter clarified is 'index' (via 'by index'), while 'map' and 'file' remain unexplained. This adds marginal value over the schema but fails to fully document the parameters, especially with three parameters present.

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 returns one sector's properties by index, with a specific verb ('Return') and resource ('sector's properties'). It distinguishes from siblings like get_linedef and find_sectors_by_tag by emphasizing the selection method (index) and scope (one sector).

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

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

The description gives no guidance on when to use this tool versus alternatives such as find_sectors_by_tag or map_info. It neither mentions exclusions nor suggests specific contexts for use, leaving the agent without enough information to select it correctly among many 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?

Without annotations, the description bears full responsibility for behavioral transparency. It explicitly states it 'Reads' the log, indicating a read-only operation. It does not cover auth needs or rate limits, but the core behavior is clear.

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 action ('Read the engine's captured console log'), no extraneous words. Every part contributes to 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?

The description explains what it does but not the return format. Given there is no output schema, the agent lacks details on how errors are surfaced. However, for a simple retrieval tool, this may be adequate.

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

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

Schema description coverage is 0%, and the description adds no information about the single parameter 'instance'. The agent must rely solely on the schema, which only provides type and default. The description should have clarified the parameter's 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 clearly states it reads the engine's console log to surface DECORATE/ACS compile errors and fatal startup errors. It distinguishes itself by noting it works when the bridge never came up, differentiating from sibling tools that require a connection.

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

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

The description explicitly states when to use this tool ('exactly when the other tools can't connect'), providing clear context. It does not explicitly mention when not to use it, but the purpose is well-scoped.

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, but it only says 'Give an inventory item to the player.' It does not mention possible side effects, prerequisites, or behavior in different contexts (e.g., menu screens, invalid items).

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, straightforward 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?

For a tool with 3 parameters, no annotations, and no output schema, this description is too minimal. It does not explain the role of 'amount' or 'instance', nor does it provide any context about inventory limits, game state requirements, or relationship to sibling tools.

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 adds no detail about the 'item', 'amount', or 'instance' parameters. The meaning of 'amount' and 'instance' is entirely undocumented, and 'item' is already self-evident from 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 (give), the resource (inventory item), and the recipient (the player). This distinguishes it from sibling tools like take and summon, even without naming them.

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

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

No guidance is provided about when to use this tool versus alternatives such as take or summon. The description only states what it does, leaving the agent to infer 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?

With no annotations provided, the description does not disclose behavioral traits. It merely lists features without stating whether the tool is read-only, if it modifies state, or any 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?

The description is very short but lacks essential information. It is not concise; it is underspecified. Every word should earn its place, but here the phrase does not convey meaningful semantics.

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, no annotations, and a single undocumented parameter, the description fails to provide enough context for an AI agent to use the tool correctly. It does not describe return values, behavior, or parameter constraints.

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 one parameter 'instance' with no description. Schema coverage is 0%, and the tool description does not mention the parameter at all, leaving its purpose and usage completely unexplained.

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 lists 'Status bar Y position, status bar / HUD scale, alt HUD, crosshair' but does not specify whether the tool reads or writes these values. The title 'HUD info' suggests read-only, but the verb is missing, making the purpose vague. Sibling tool 'read_hud' likely overlaps and is not distinguished.

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

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

No guidance on when to use this tool versus alternatives like 'read_hud', 'map_info', or 'viewport_info'. No context or prerequisites are given.

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

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

With no annotations, the description must fully disclose behavior. It mentions running 'linetarget' but does not clarify if this is read-only, if it can fail (e.g., no target), or any side effects. The agent lacks information about safety or state impact.

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, direct sentence that states the command and return fields. It is efficient and front-loaded, but slightly too brief given the lack of parameter explanation.

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 omits important details: parameter meaning, error handling, and output format. Without an output schema, more context about the returned data structure would be valuable.

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 only parameter 'instance' is not described in the tool description. Schema coverage is 0%, so the agent has no explanation of what 'instance' refers to (e.g., game instance number, player instance). This is a critical 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 runs 'linetarget' and returns the aimed actor's class, health, and spawn health. It is specific about the resource and action, and distinguishes from siblings like 'actors_near' which lists nearby actors rather than the current target.

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

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

No guidance on when to use this tool versus alternatives (e.g., 'actors_near', 'actor_state'). No prerequisites, error conditions, or context hints are provided, leaving the agent to infer when this tool is appropriate.

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

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

No annotations exist, so description carries full burden. It discloses the two-step process (soft then force kill) and explains the macOS GPU teardown issue. Could mention reentrancy safety, but overall transparent.

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

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

Two sentences with no fluff: first states the purpose, second explains the method and rationale. Ideal front-loading and brevity.

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 one parameter and no output schema, the description covers the behavioral process well. Missing parameter documentation reduces completeness slightly.

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 mention the 'instance' parameter despite 0% schema coverage. The parameter's meaning and default (1) are only inferable from the name. 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 stops a launched instance and detaches from it, using a two-step process. This distinguishes it from sibling tools like load_map or set_pause.

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 terminating instances but does not explicitly say when to use it or mention alternatives. It provides context about the graceful exit rationale but 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions spawning and attaching but does not explain what 'attach' means, whether the process runs synchronously, or what side effects occur (e.g., creating a new instance). The requirement for ZANDRONUM_EXE adds context, but overall it lacks 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 concise sentences that are front-loaded with the primary action ('Spawn...') and the critical prerequisite. Every word earns its place, and there is no redundant or vague 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?

This is a complex tool with 9 parameters, no output schema, and no annotations, yet the description is only two sentences. It fails to explain parameter semantics, return values, error conditions, or how it interacts with the instance lifecycle. The description is far from sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description only says 'with the given options' without explaining any of the 9 parameters. Parameter names like map, iwad, skill are somewhat self-explanatory to domain experts, but the description adds no semantic meaning beyond the schema, leaving ambiguous parameters like instance and extraArgs undocumented.

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: 'Spawn a bridge-enabled Zandronum process with the given options and attach to it.' This specific verb-resource pairing distinguishes it from siblings like attach_instance and kill_instance. The title is consistent with the description.

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

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

The description provides a clear prerequisite ('Requires ZANDRONUM_EXE to be set') but does not explicitly state when to use this tool versus alternatives like attach_instance. The usage context is implied by the name and action, but no exclusions or alternative recommendations are given.

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

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

With no annotations, the description must fully disclose behavior. It states it runs a command and returns non-zero variables, but does not mention potential side effects (e.g., is dumpacsvars safe?), required permissions, or what happens if no variables are found. The lack of detail reduces 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, efficient sentence that conveys the essential information without waste. It is front-loaded with the action and result.

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 has no output schema, no annotations, and two parameters with a technical domain (ACS variables), the description is too brief. It lacks information about return format, error handling, and the meaning of the 'instance' parameter. For a complete understanding, the agent would need external knowledge.

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 should add meaning. It only mentions the 'scope' parameter indirectly ('optionally filtered by scope') but does not explain the 'instance' parameter at all. The schema provides enum for scope, but the instance parameter's purpose (e.g., which instance's variables) is left unclear.

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 that the tool runs `dumpacsvars` and returns all non-zero ACS world/global variables, with optional filtering by scope. This is a specific verb (list/return) and resource (ACS variables), and it implicitly distinguishes from siblings like `get_acs_var` (single variable) and `set_acs_var` (modify).

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. It does not mention that `get_acs_var` or `find_acs_symbol` might be better for specific variable lookups, nor does it state any prerequisites or context for use.

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 that the tool invokes the `dumpactors` command and returns structured data, implying a read-only listing. However, it does not mention potential side effects, error conditions, or the format of the structured data, leaving some ambiguity.

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 is concise and front-loaded with key information. 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 output schema covers return values, and the tool is conceptually simple. However, the missing explanation of the `instance` parameter leaves a gap in the contextual information needed to use the tool correctly. Additional mention of how `instance` relates to the game instance 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 only parameter, `instance`, has no description in the schema (0% coverage), and the tool description does not mention it. An agent has no way to know what instance to provide or why it defaults to 1.

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

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

The description states a specific action ('Run dumpactors and return') with a clear resource ('registered DECORATE/actor classes') and scope. It clearly distinguishes from siblings like actor_state or inspect_target, which focus on individual actors.

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 actor_state or inspect_target. There are no context cues, exclusions, or examples of appropriate 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 carries full burden. It states the tool runs a command but does not disclose whether it is read-only, requires permissions, or if there are side effects. For a listing tool, likely safe, but not explicit.

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 conveys the core action concisely. It avoids redundancy and is front-loaded with 'Run `dumpfunctions`'. However, it could be slightly more structured by separating the parameter explanation.

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 simple tool (one optional parameter, no output schema), the description covers the basic purpose but lacks parameter semantics and behavioral details. It is minimally adequate but could be more complete by explaining 'instance' and return format.

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

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

Schema description coverage is 0% for the single parameter 'instance', and the tool description does not mention it at all. The parameter's purpose (e.g., specifying a module instance) is unclear. The description adds no value beyond the schema structure.

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 runs `dumpfunctions` and returns named ACS functions across loaded modules. It uses specific verbs and resource references, and it distinguishes from sibling tools like list_scripts (scripts) and list_acs_vars (variables). However, it could be more precise about the scope.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies it is for listing ACS functions, but does not mention when not to use it or suggest other tools for related tasks. With many sibling tools, this omission hurts usability.

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

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

The description mentions running a command and includes a note about map vars' lifetime, offering some behavioral context. However, it does not specify whether the tool is read-only, has side effects, or requires a loaded map.

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 with two sentences. The second sentence about map vars is somewhat tangential but does not significantly hinder 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?

While the return values (id + name) are stated, the description omits important context such as the meaning of the 'instance' parameter, whether results depend on a loaded map, or any prerequisites. This leaves gaps 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?

Schema description coverage is 0%, yet the description provides no explanation for the 'instance' parameter. The parameter remains undocumented, failing to compensate for the schema's lack of descriptions.

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 runs `dumpmodules` and returns loaded ACS modules with id and name. The name 'list_modules' and title directly describe the action, and it is distinct from sibling tools like list_acs_vars, list_scripts, etc.

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

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

No guidance on when to use this tool over alternatives is provided. It does not mention context like prerequisites, conditions, or comparisons to other listing 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 exist, so the description carries full burden. It discloses that the tool runs an external command ('scriptstat'), implying it may execute actions. However, it does not explain side effects, permissions needed, or behavior when no scripts are running. Adequate but not thorough.

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, no redundancy. However, it could be slightly more informative without sacrificing 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?

While output schema exists, the description omits explanation of the parameter and does not elaborate on what 'states' means. Missing critical context for correct invocation.

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

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

Schema coverage is 0%, and the description does not mention the 'instance' parameter at all. The agent is left to guess its purpose and format with zero guidance.

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 ('Run `scriptstat` and return') and the resource ('currently running ACS scripts and their states'). It distinguishes from sibling 'list_scripts' by specifying 'running', making the purpose 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?

No explicit guidance on when to use this tool versus alternatives like 'list_scripts'. The description does not mention contexts, prerequisites, or 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?

Without annotations, the description discloses that it reads metadata from PNG text chunks and doesn't require a running game. It doesn't mention if it modifies anything (likely not) or what happens if the directory doesn't exist. Moderate 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 sentence that efficiently conveys the tool's purpose, scope, and key constraint. No wasted words.

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

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

The description covers the main functionality and condition, but doesn't specify the output format (e.g., list of files vs. metadata), and the parameter is underspecified. Given the simplicity of the tool, it's 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 only parameter 'dir' has no schema description (0% coverage). The description mentions 'save directory' but doesn't explicitly state that 'dir' allows specifying a custom directory path or that it's optional. Some context is provided but not enough for an agent to understand the parameter's role.

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 .zds savegames with metadata from PNG text chunks, and specifies no running game needed. This is a specific verb+resource combination that distinguishes from sibling tools like load_game or save_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 says 'No running game needed,' indicating a key usage context. However, it doesn't provide when-not-to-use guidance or mention alternatives among the many sibling tools, which is a gap given the large sibling list.

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 underlying command (`dumpscripts`) and the output fields, giving some behavioral insight. However, it does not mention whether the operation is read-only, any prerequisites like a running instance, or potential side effects, leaving some behavioral ambiguity.

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 is concise and front-loaded with the action. It includes the essential output details without any fluff, earning a perfect score for structure.

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 adequately explains what the tool returns but omits details about the `instance` parameter and any prerequisites. Given the tool's simplicity and lack of output schema, the description is decent but not fully complete for an agent to invoke it without additional assumptions.

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 one parameter, `instance`, but the description provides no explanation of its meaning or usage. With schema description coverage at 0%, the description fails to compensate, leaving the purpose of `instance` (presumably the game instance ID) unclear.

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 runs `dumpscripts` and returns every script with specific fields (module, number, name, type, arg count). This is a specific verb+resource with clear scope, and it distinguishes from sibling tools like list_running_scripts by emphasizing 'every script across loaded modules'.

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 enumerating all scripts, while list_running_scripts presumably covers active scripts, but it does not explicitly mention alternatives or when not to use it. The context is clear enough for basic usage but lacks explicit guidance on choosing this over similar 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 must disclose behavior. It states 'restore' implying a state change, but does not mention whether it overwrites current state, requires an active instance, or has side effects. This lack of detail is a significant gap for a mutation tool.

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

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

The description is a single sentence, concise and front-loaded. The phrase 'Run `load`' is somewhat redundant with the tool name, but it does convey the underlying command. Overall, it is efficiently written without excess.

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 has two parameters, no output schema, and no annotations, the description is insufficient. It does not explain the `instance` parameter, return values, or any prerequisites (e.g., a running game instance). This makes the tool incomplete for an agent to invoke correctly in varied contexts.

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 explain parameters. It mentions 'by name' for the `name` parameter but entirely ignores the `instance` parameter. Since instance is not self-explanatory and the schema provides no description, the agent is left guessing its purpose.

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: 'restore a savegame by name', with a specific verb and resource. It distinguishes itself from siblings like save_game and list_saves by focusing on loading, 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?

The usage is implied: use this when you want to restore a saved game. However, there is no explicit guidance on when not to use it or which sibling tools might be more appropriate, leaving some 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 provided, and the description gives no behavioral details beyond 'load a map'. For a state-changing operation, it should disclose side effects (e.g., replaces current map), permission requirements, or state implications.

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, directly to the point, no unnecessary words. Front-loaded with 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?

Adequate for a simple tool with no output schema, but missing context about side effects (e.g., overwrites current map) and the role of the 'instance' parameter.

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%. The description adds meaning for mapName via examples of lump names (MAP01, E1M1), but provides no explanation for the 'instance' parameter, leaving its purpose unclear.

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 (load), resource (map), and the key identifier (lump name) with examples (MAP01, E1M1). Distinguishes from sibling tools like load_game, which load saved games rather than maps by lump name.

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

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

No guidance on when to use this tool vs alternatives (e.g., map_info for querying, load_game for saved games). No prerequisites or exclusions mentioned.

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 full burden. It discloses a read operation and offline capability, but does not mention error handling, permissions, or detailed behavior (e.g., what happens if the map doesn't exist).

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 purpose, no wasted words. Every sentence adds value.

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

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

The description lacks parameter details and return structure explanation. With no output schema, it should specify what 'entity counts' includes and the format of the response. It is adequate for a simple tool but incomplete.

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 clarify the meaning of the 'map' and 'file' parameters. It only indirectly references reading a map, adding minimal value beyond the schema structure.

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 reads a map from a WAD and returns format and entity counts, with specific format types (doom/hexen/udmf). It distinguishes from siblings like load_map by noting the game need not be running.

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 offline use ('the game need not be running'), providing clear context. However, it does not explicitly state when not to use this tool or mention alternatives among siblings.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It does not disclose what happens if no menu is active, whether the action is reversible, or any error conditions. The statement implies a mutation but gives no safety or side effect details.

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

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

The description is a single, clear sentence (12 words) with no wasted words. It is front-loaded with the verb and immediately conveys the core action.

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 no output schema and no annotations, the description lacks important context. It does not explain the need for an active menu, the effect of the 'instance' parameter, or the return behavior. Sibling tools suggest more context is needed for appropriate selection.

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%, yet the description adds no value beyond what the schema provides. The 'key' parameter's enum values are in the schema, and 'instance' is not mentioned at all. The description fails to explain the meaning or usage of either parameter.

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

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

The description clearly states the tool sends a single menu navigation key (GUI key event) to the active menu. It uses a specific verb and resource, but does not explicitly differentiate from sibling tools like menu_nav which might handle multi-key sequences.

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

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

No guidance on when to use this tool versus alternatives such as menu_nav or menu_text. The description does not mention prerequisites (e.g., an active menu) or conditions under which the tool should be chosen.

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?

Discloses a small delay between keys, but does not mention prerequisites (e.g., menu must be open) or constraints on sequence length.

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, front-loaded with action, no wasted words.

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

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

Minimal but sufficient for a simple tool; however, lacks output schema and context on delay timing or error 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?

Describes only the 'steps' parameter with examples; the 'instance' parameter (integer, default 1) is not mentioned, and schema has no descriptions.

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 it navigates a menu by sending a sequence of keys, distinguishing from siblings like menu_key (single key) and menu_text (text input).

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

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

No guidance on when to use this tool vs alternatives, such as menu_key for single key presses or verify_menu to check menu state.

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

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

The description reveals that typing happens one character at a time, which is a behavioral detail. However, with no annotations provided, it lacks information on side effects, error conditions (e.g., no active field), or required permissions.

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 of 28 words, front-loading the key information. Every word is functional 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?

Given no output schema and no annotations, the description should cover return behavior, prerequisites (e.g., field must be active), and error handling. It omits all of these, making it incomplete for safe 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?

The schema has 0% description coverage, and the description only says 'Type a string', adding no value beyond the parameter name 'text'. The 'instance' parameter is not explained at all, leaving its purpose unclear.

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 types a string into the active menu text-entry field one character at a time. The verb ('type') and resource ('menu text-entry field') are specific, but it does not distinguish from sibling tools like 'menu_key' which may perform similar actions.

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 it should be used when needing to input text into a menu text field, but it does not provide explicit guidance on when not to use (e.g., for single key presses) or mention alternatives like 'menu_key'.

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 the press-and-release sequence, drag mechanics (press at first point, move, release at second), and double-click behavior. However, it omits details like coordinate system and whether the mouse pointer moves to the target position before clicking.

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 two sentences that clearly convey the tool's purpose and variations. Every clause adds value, including the conditional drag and double-click explanations.

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 six parameters and no output schema, the description covers the core mouse actions but lacks context on coordinate system, instance handling, and how this tool differs from mouse_move. It is adequate but not fully comprehensive.

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%, so the description must compensate. It explains toX/toY as drag endpoints, double as double-click, and x/y as the position, but leaves the instance parameter unexplained. This partial coverage is sufficient for a moderate score.

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 primary action: pressing and releasing the left button at a position. It also explains the drag variant and double-click, distinguishing it from siblings like mouse_move and mouse_wheel by focusing on button interactions.

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

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

Usage is implied through the description of click and drag behaviors, but there is no explicit guidance on when to choose this tool over alternatives like mouse_move. It does not mention when not to use it or provide comparison to siblings.

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

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

With no annotations, the description carries the full burden. It discloses the coordinate origin (pixels from top-left of the game window) and that it drives hover-only UI, implying a non-click action. However, it does not mention possible side effects, whether movement is instant, or what the return value indicates. It provides some context 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?

The description is exactly two sentences, front-loaded with the primary action, and every phrase earns its place. It conveys purpose, coordinate semantics, and a use case without excess 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 simple tool, the description covers the main purpose and coordinate system, but it omits the 'instance' parameter entirely and provides no return value or side-effect details. Given no annotations or output schema, this leaves some gaps in the agent's understanding of the full 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?

Schema coverage is 0%, so the description must compensate. It explains x and y as pixel coordinates from the top-left of the game window, which adds meaning beyond the schema. However, the 'instance' parameter is not mentioned at all, leaving its role unclear despite being part of 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 action as moving the pointer to a screen position, with a specific coordinate system. It also distinguishes this tool from siblings by noting it drives hover-only UI, which 'nothing else here can reach', directly separating it from mouse_click and mouse_wheel.

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

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

The description gives a clear context for when to use this tool: for hover-only UI (tooltips, hot states). It implies that other tools cannot achieve this, so it should be used for these cases. However, it does not explicitly name alternatives or state when not to use it, such as when clicking is 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?

With no annotations provided, the description carries the full burden. It discloses that the action occurs at the current pointer position and explains the effect of positive/negative values. While it doesn't discuss side effects or prerequisites, the behavior is straightforward and clearly described.

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 concise sentences that immediately convey the tool's purpose and key behavior. No wasted words, and the structure front-loads the core action.

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 input tool with two parameters and no output schema, the description covers the main operation and direction semantics. It lacks an explanation of the 'instance' parameter, but the default value and common usage across sibling tools mitigate this 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 description explains the meaning of the 'notches' parameter (positive scrolls up, negative down), which is valuable given the 0% schema description coverage. However, it does not explain the 'instance' parameter, leaving one of two parameters undocumented.

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 scrolls the mouse wheel at the current pointer position, with positive/negative values indicating direction. This distinguishes it from sibling tools like mouse_move and mouse_click.

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 explaining the action, but it does not provide explicit when-to-use guidance or mention alternative tools. No exclusions are given, but the context of when to scroll vs. click/move is only implicitly understood.

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 description carries full burden. It only states basic playback functionality, omitting details on side effects, required game state, error handling, or termination 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?

Two concise sentences with no excess. However, leading with 'Run `playdemo`' is slightly technical; a more action-focused opening would improve front-loading.

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 low complexity (2 params, no output schema, no annotations), the description remains too minimal. Missing details on expected behavior, results, and potential errors, leaving the agent underinformed.

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 description does not mention either parameter ('name' or 'instance'). The agent gains no semantic insight beyond raw schema types and constraints.

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 plays back a recorded .lmp demo using the `playdemo` command, and distinguishes this from recording which is done via launch arg. Purpose is specific and 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?

No explicit when-to-use or when-not-to-use guidance. The description mentions recording is separate, which indirectly suggests use for playback, but doesn't provide context for alternatives or prerequisites.

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

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

No annotations provided. Description mentions running a command but does not clarify if it is read-only, requires specific permissions, or has side effects. 'Run' may imply execution, but likely safe.

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, no extraneous information. Efficiently states the core functionality.

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?

Lists returned fields, which is useful. However, missing parameter explanation and usage context. No output schema to compensate for return value details.

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?

Input schema has one parameter 'instance' with no description. Description does not mention this parameter at all, leaving its meaning unexplained despite 0% 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 it returns player position, angle, floor height, sector, and light level by running a specific command. Distinguishes from sibling 'actor_state' which targets actors, but could be more abstract.

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

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

No guidance on when to use this tool versus alternatives like 'actor_state' or 'map_info'. No context about prerequisites or constraints.

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 runs 'acsprofile' and returns stats, but omits whether it is read-only, requires a specific instance, or has side effects. This lack of transparency makes it hard to anticipate operational impact.

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 that front-loads the action and output. It contains no filler or redundant wording, making it easily parseable.

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?

Without an output schema or annotations, the description must provide enough context to use the tool correctly. It gives a high-level return description but omits parameter meanings, exact output format, and any usage prerequisites, leaving significant ambiguity for an agent.

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

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

Schema description coverage is 0%, so the description must clarify parameters. It lists metrics ('total instructions, runs, avg/min/max') that align with the sort enum, but does not explicitly explain 'sort', 'limit', or 'instance'. The description adds minimal meaning beyond the schema's raw enum and integer types.

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 ('Run acsprofile') and the resource ('per-script/function execution stats'), with specific metrics listed. This distinguishes it from sibling tools like list_scripts or get_acs_var, 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?

No guidance is provided on when to use this tool versus alternatives. The description only states what it does without any context for selection, such as prerequisite conditions or comparisons to related tools like profile_window.

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 clearly states that it clears ACS profiling, waits N seconds, and returns results. This discloses the destructive side effect of clearing profiling, which is good.

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 a dash, which is concise but omits important parameter details. It is not inefficient, but sacrifices completeness for brevity.

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 4 parameters, no output schema, and no parameter explanations, the description is incomplete. Users are left guessing about sort options, limit behavior, and instance meaning. The complexity of a profiling tool demands more 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 0%, so the description must add meaning for all 4 parameters. It only mentions 'seconds' implicitly via 'wait N seconds', but fails to explain 'sort', 'limit', and 'instance'. 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 verb 'profile' and resource 'time window', and distinguishes from cumulative profiling with the phrase 'what's hot right now rather than cumulative since map start'. It is specific and differentiates from sibling tools like profile_scripts.

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 non-cumulative profiling ('what's hot right now'), but does not explicitly name alternatives or state when not to use. It provides context but lacks explicit exclusion 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 bears full responsibility for behavioral disclosure, but it only describes the output. It does not state whether reading is side-effect-free, performance implications, or required permissions.

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 command and clearly lists return types. While efficient, it could be slightly more structured by separating parameter info.

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 details the complex return value well, which is positive given no output schema. However, it omits the meaning of the instance parameter, so context is incomplete for full 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?

Schema coverage is 0% and the description adds no information about the 'instance' parameter. The agent gets no help understanding what the parameter does or its default behavior.

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

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

The description clearly states the tool runs dumphud and returns all HUD elements from the last frame, listing specific data types. It does not explicitly differentiate from siblings like hud_info or menu_text, but the level of detail implies comprehensive capture.

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

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

No guidance on when to use this tool over alternatives. It does not mention prerequisites, context, or when to choose read_hud instead of hud_info or other menu-related tools.

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

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

No annotations are provided, so the description must disclose behavioral traits like read-only nature, performance impact, or side effects. It only lists output fields, not even stating it is a query. This is insufficient for a tool with no annotations.

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

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

The description is extremely concise, consisting of a single sentence that lists the output fields without any superfluous words. Every element earned 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 tool has one parameter and no output schema, the description should explain the parameter and state what the return value looks like. It only partially covers the output (by listing fields) and omits parameter explanation, making it incomplete for effective 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?

The input schema defines a single parameter 'instance' with no description, and the tool description does not mention it at all. With 0% schema coverage, the description should explain the parameter's meaning and default value, but it fails completely.

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 lists the information returned: active backend, GL vendor/shader model, resolution, fullscreen/vsync. It uses specific nouns and implies the tool provides renderer info, distinguishing it from sibling tools like viewport_info or hud_info, though not explicitly.

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 does not provide any guidance on when to use this tool versus alternatives, nor does it state prerequisites or exclusions. It only implies usage when renderer details 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 exist, so the description carries the full burden. It explicitly states what gets killed, what is left alone ('Engines belonging to another running editor window are left alone'), and the effect and risk of all:true. This is thorough behavioral disclosure for a destructive 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?

Three dense sentences with no filler, front-loaded with the primary action. Every sentence adds essential information about scope, exclusions, and parameter usage.

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 (1 param, no output schema), and the description thoroughly explains scope, behavior, and the optional parameter. The only minor gap is not describing return values, but for a cleanup operation this is acceptable.

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

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

The schema already fully describes the 'all' parameter (100% coverage), and the description reinforces its meaning and adds a safety condition. Baseline 3 applies, but the extra guidance justifies a 4.

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 'Kill every instance this session launched, and reap engines ORPHANED by earlier sessions,' which specifies the verb (kill/reap) and resource (engine instances). It clearly distinguishes itself from sibling kill_instance by focusing on session-level cleanup and orphan reaping.

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 explains when to use the tool (to clean up session instances and orphaned engines squatting bridge ports) and provides caution for the 'all' parameter ('only do that if you know no other session is using this engine build'). No explicit alternative tool is named, but the scope is clear enough to infer.

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 behavioral disclosure burden. It only states that output is captured, but does not disclose potential side effects, risk to the instance, or that raw commands may mutate state. This is a significant transparency gap for a command execution 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, front-loaded sentence that conveys the essential action and return behavior without redundancy or waste. It is optimally 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?

Given the tool's potential for side effects and the absence of annotations or an output schema, the description should cover safety considerations, parameter semantics, and edge cases. It only provides the basic action and return behavior, leaving critical gaps for an agent to invoke the tool safely and 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?

The input schema has 0% description coverage, so the description must compensate. It only implicitly indicates that 'text' is the command and 'instance' is the target, but does not explain the instance parameter's meaning, default, or format, nor does it clarify how the command is processed. Minimal additional meaning is provided over 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 ('Send'), the resource ('raw console command'), the target ('running, bridge-patched Zandronum instance'), and the return behavior ('captured output'). It distinguishes this tool from siblings like run_script, which execute scripts rather than raw commands.

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 sending raw console commands but does not explicitly state when to use this tool versus alternatives like run_script, nor does it mention exclusions or prerequisites. The usage context is only implied by the wording.

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 bear full transparency burden. It only says 'Run (puke)' without explaining side effects, destructiveness, authentication, or what happens on success/failure. The parenthetical 'puke' is unclear jargon.

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, very concise. However, the inclusion of 'puke' adds unnecessary jargon that may confuse. It is front-loaded but could be more user-friendly.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. It does not cover return value, error conditions, or effect on the system. The agent lacks critical information 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 description coverage is 0%, yet the description only mentions 'optional integer arguments' (args). It does not explain the meaning of 'script' (number or name), 'always' (boolean), or 'instance' (integer with default). No additional semantics beyond 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 tool runs an ACS script, specifying identification by number or name and optional integer arguments. This distinguishes it from sibling tools like list_scripts or get_acs_var.

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 such as run_command or list_scripts. There is no mention of prerequisites or typical 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?

With no annotations, the description carries the burden and does add a concrete warning about crashes on heavily-scripted mods. However, it does not disclose other behavioral details such as overwrite behavior, return values, 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?

Two sentences, front-loaded with the primary action and followed by a critical caveat. Every sentence 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?

While the warning adds important context for a mutation tool with no annotations, the description omits useful information about the parameters, save behavior, or result. It is adequate but leaves gaps for a 3-parameter tool with no 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?

Schema description coverage is 0% and the description names none of the parameters (name, instance, description). It does not compensate for the lack of schema documentation, leaving parameter meaning to inference.

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 writes a savegame, specifies single-player/cooperative scope, and differentiates from sibling tools like load_game and list_saves by naming the action 'save'.

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 context on when to use (single-player/cooperative) and an explicit warning against heavily-scripted mods (All-out-War), effectively indicating when not to use. However, it does not name alternatives explicitly, 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 provided, so description must disclose all behavioral traits. It states the action and output but omits details like side effects, performance implications, or output format (raw bytes, base64, etc.).

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?

Extremely concise at one sentence, but brevity sacrifices necessary detail about the parameter and output.

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?

Lacks explanation of the single parameter and does not describe the return format or image properties, making it incomplete for effective 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 0%, and the description does not mention the 'instance' parameter, leaving its purpose and meaning entirely unexplained.

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?

Describes taking a screenshot of the game and returning an image, which is clear but lacks specificity about what is captured (e.g., full screen, current view). Differentiates from siblings as the only screenshot tool.

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

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

No guidance on when to use this tool versus alternatives, such as when to capture an image vs. retrieving raw data from other 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Write,' which implies a mutation, but does not disclose side effects, scope persistence, or error behavior for invalid indices. No mention of the optional instance parameter or its effect on game 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 concise sentence with no excess wording. It effectively communicates the core action in minimal space.

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 4 parameters, no annotations, and no output schema, this description is too thin. It lacks crucial context such as instance semantics, side effects on game state, prerequisites (e.g., running game), and relationship to get_acs_var/list_acs_vars.

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 explains 'world or global' (scope) and 'by index' (index), but omits the 'instance' parameter entirely and does not clarify the meaning of 'value' beyond the obvious. This is insufficient for a 4-parameter tool with no schema descriptions.

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 'Write' and identifies the resource as 'an ACS world or global variable by index.' This clearly distinguishes it from sibling tools like get_acs_var (read) and list_acs_vars (list).

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, no prerequisites, and no mention of when not to use it. It simply states the action without 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?

With no annotations, the description should detail behavioral traits. It only says 'Write', implying mutation, but omits side effects, error handling, permission requirements, or any consequences. The behavior is minimally 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 a single 13-word sentence, making it very concise. However, it sacrifices essential information, so the conciseness is not optimally balanced with completeness.

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

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

Given the tool has 4 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to cover all parameters, lacks behavioral context, and does not explain the return value or side effects.

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%; the description mentions only 'name' and 'index' but ignores 'value' and 'instance'. It adds no meaning to the schema, leaving the agent to guess the role of each 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 clearly states the action ('Write') and the resource ('element of a map-scope ACS array') with the key parameters (name and index). It implicitly distinguishes from sibling tools like get_map_array, but lacks explicit differentiation.

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

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

No guidance on when to use this tool versus alternatives (e.g., get_map_array, set_map_var) or any context about prerequisites or constraints. The description simply states what it does without usage recommendations.

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?

There are no annotations, so the description carries the full burden. It states 'Write' which indicates a mutation, but it doesn't disclose whether the variable is created if absent, the role of the 'instance' parameter, or any side effects. The schema's 'instance' field suggests multi-instance support, which is unmentioned.

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 entire description is one sentence with no filler words. It is front-loaded and to the point, though it sacrifices content for brevity.

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, an output schema, and parameter descriptions, the tool description is inadequate. It fails to explain the instance parameter, differentiate from set_acs_var, or specify behavior when the variable doesn't exist. A more complete description would cover these aspects.

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%, so the description must compensate for the three parameters. It implicitly covers 'name' ('by name') and 'value' (the thing written), but it completely omits 'instance' and gives no details about value constraints or how the variable is addressed.

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 'Write' and names the resource as 'map-scope ACS variable', clearly distinguishing it from sibling tools like set_acs_var (which likely operates on a different scope) and get_map_var (which reads instead of writes). The 'by name' qualifier indicates it operates on a single named variable.

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 instead of alternatives like set_acs_var or set_map_array. It doesn't mention scope differences or any prerequisites such as an active map session.

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 details. It mentions setting the master pause flag but does not explain side effects, required permissions, or interaction with other pause mechanisms. Adequate but not thorough.

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 purpose, the second adds context. No unnecessary 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?

With no output schema and zero parameter documentation, the description is incomplete. It lacks essential information for correct invocation, such as what 'paused' true/false means and what 'instance' refers to.

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 mention either parameter ('paused' or 'instance') despite schema coverage being 0%. The agent has no guidance on what values to use or what the instance parameter controls.

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: 'Set the engine's master pause flag directly.' It also provides a specific use case (resuming a backgrounded instance that auto-paused on focus loss), distinguishing it from other pause-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?

The description explicitly tells when to use this tool: to resume a backgrounded instance. This provides clear context and helps the agent decide between this and other 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 behavioral burden. It discloses that the game resumes, runs for a specified number of tics, then pauses again, and notes the 'deterministic-ish' nature. Missing edge cases (e.g., if the game is already running) but core behavior is covered.

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

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

Two concise sentences deliver all essential information without unnecessary detail. The main action and purpose are front-loaded.

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

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

For a two-parameter tool with no output schema, the description covers purpose, behavior, and typical use. The only notable omission is the 'instance' parameter, which prevents full 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 description explains 'tics' well (35 tics = 1 second) and its purpose. However, the 'instance' parameter is not mentioned at all, leaving its meaning ambiguous. Given 0% schema coverage, the description partially compensates but not fully.

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: resume the game, run for N tics, then pause. This distinguishes it from siblings like set_pause or run_script by focusing on time advancement.

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 a clear use case: observing time-based effects without keeping the window focused. It lacks explicit 'when not to use' or direct alternative names, but the context is sufficient for basic 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 disclosing side effects. It only states that an actor is spawned at the player's position, but does not mention whether this is persistent, what happens if the class name is invalid, whether spawn limits apply, or any other consequences. It also doesn't explain the meaning of 'kind' or 'instance' in behavioral terms.

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 immediately identifies the action and target. There is no fluff or redundant wording, and it is front-loaded with the verb 'spawn'. It earns its place perfectly.

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 three parameters, no output schema, and no annotations, the description is too sparse. It doesn't explain what the tool returns after summoning, how 'kind' affects resulting behavior, or what happens if an invalid class is used. An agent would lack sufficient information to safely invoke this tool without additional research.

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 clarify all parameters. It indirectly explains className ('given class') and provides useful context for why no position parameter exists (spawns at player's position). However, it provides no meaning for 'kind' (normal/friend/foe) or 'instance' (count?), and does not interpret the enum or default values.

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 'spawn' to identify the action, names the resource as 'an actor of the given class', and specifies the location as 'the player's position'. This clearly distinguishes it from sibling tools like give/take (item manipulation) and list_actor_classes (querying).

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 or when to prefer alternatives. For example, it doesn't mention that list_actor_classes should be called first to find valid class names, nor does it explain differences between summon and give or actors_near. No exclusions or prerequisites are provided.

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

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

With no annotations, the description carries the full burden. It only states the action but fails to disclose what happens if the item doesn't exist, or if the amount exceeds the player's stock, or the role of the 'instance' parameter.

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, which is concise. However, it is too brief to convey necessary details, bordering on under-specification rather than efficient communication.

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 3 parameters and no output schema, the description is highly incomplete. It omits parameter details, behavior, error handling, and any guidance on usage context.

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

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

Schema coverage is 0% with no parameter descriptions. The tool description does not explain the meaning of 'item', 'amount', or 'instance', leaving the agent without context for these 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 'Remove an inventory item from the player' clearly states the action and resource. It distinguishes from sibling tools like 'give' (adds item) and 'summon' (creates actor).

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

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

No guidance on when to use this tool vs alternatives. For instance, when to use 'take' instead of 'kill_instance' or 'run_script' to remove an item is not addressed.

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

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

With no annotations, the description must disclose behavioral traits. It mentions the sequence of actions but does not describe side effects, error behavior, or whether the screenshot is returned immediately or stored. The mechanism 'like menu_options' 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?

The description is a single sentence that conveys the core workflow efficiently. It is front-loaded with the main action. Some additional structure (bullet points) could improve readability, but it remains 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?

Given no annotations, no output schema, and complex context (multiple sibling tools), the description is incomplete. It does not specify the return format, error handling, prerequisites (e.g., game state), or how to interpret the screenshot. The tool's composition nature is not fully explained.

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%, so the description should compensate. It explains 'steps' as navigation steps with enum values, but 'open' and 'instance' are not described beyond their names. The meaning of 'open' (console command) is hinted but not specified.

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: open a menu via console command, apply navigation steps, and return a screenshot. This verb-resource combination distinguishes it from sibling tools like menu_nav or screenshot alone.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., menu_nav + screenshot separately). There is no mention of prerequisites or scenarios where it is appropriate or inappropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the tool is read-only, has no side effects, or any other behavioral traits. While the name 'viewport_info' hints at information retrieval, the description itself gives no explicit safety or side-effect information.

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 phrase that directly states the core data content without padding or redundancy. It is front-loaded and every word contributes meaningful 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?

For a simple info tool with one optional parameter and no output schema, the description partially explains the return content (viewport rect and screenblocks size). However, it fails to mention how the 'instance' parameter influences the result, and it does not describe the output format or any error conditions, leaving notable gaps for an agent.

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

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

Schema coverage is 0%, and the description does not mention the 'instance' parameter at all. There is no explanation of what 'instance' refers to (e.g., game instance, window ID) or how it affects the result, leaving the agent without meaningful semantic guidance beyond the bare schema definition.

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 resource (3D view window rect and screenblocks size) and the specific data fields (x/y/width/height), establishing what info is provided. However, it lacks a verb like 'gets' or 'returns', and it does not explicitly differentiate it from sibling tools such as renderer_info or hud_info.

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, no context, and no exclusions. It simply states the data contents without indicating scenarios or prerequisites.

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