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

No annotations are provided, so the description carries the full burden. It states the tool runs a command and returns output tail, but does not disclose side effects, prerequisites (e.g., MAME and ROMs must be present), timeout behavior, exit codes, or the exact nature of the returned 'tail'. This is a significant 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 sentence that is specific and free of fluff. It front-loads the key command and output detail, earning its place without unnecessary wording.

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

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

The tool has no output schema, so the description should clarify the return value. It says 'audit output tail' but does not specify what 'tail' means (line count, summary, etc.) or whether stderr is included. However, all parameters are well-documented in the schema, which mitigates the gaps. Overall, it is adequate but leaves ambiguity about the output format.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal parameter context by showing `system` in the command, but it does not meaningfully elaborate on parameters beyond the schema. The schema already handles the parameter semantics adequately.

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 a specific command (`mame -verifyroms <system>`) and returns the output tail. This is a specific verb+resource combination that distinguishes it from sibling tools that handle gameplay, Lua execution, or memory access.

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

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

The description implies usage (when you need to audit a romset), but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. There is no mention of alternative tools or scenarios where this tool should be preferred.

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 for behavioral disclosure. It does not mention that the tool launches MAME, requires ROMs, writes scripts/logs, or modifies emulator state. The injection of inputs and recording of CCR suggests side effects, but whether this is safe or reversible is not disclosed. Missing operational details significantly impair trust.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no filler. However, the dense jargon and specialized terminology reduce immediate clarity for a generic agent, making it less accessible than it could be.

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

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

Despite having 15 parameters and no output schema, the description is minimal. It does not explain what the tool returns, how to interpret a 'golden-vector', prerequisites like MAME/ROM paths, or the overall workflow. The sibling list suggests integration into a complex pipeline, but the description lacks operational context needed for reliable invocation.

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

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

Schema coverage is 100% with per-parameter descriptions, so the baseline is 3. The description adds conceptual context ('one memory word/byte', 'CCR') but doesn't map these to specific parameters or clarify how inputs/taps relate to the schema fields. It provides minimal added value beyond the schema.

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

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

The description clearly states the tool captures golden-vector outputs from a pure leaf function that transforms memory in place, and explicitly notes it injects inputs and records output + regs + CCR. It distinguishes itself from siblings like mame_capture_game_tick by focusing on differential-harness oracles, though the heavy jargon ('leaf', 'taps') may be opaque to non-specialists.

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 identifies a specific use case: serving as an independent oracle for the transpiler differential harness. This implies when to use the tool, though it does not explicitly mention alternatives or exclusions. The context is meaningful but could be more directive.

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 mentions resolving paths and reporting existence, but does not specify what 'required pieces' are, whether the tool has side effects, what the output format is, or what happens if pieces are missing. Minimal and 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, front-loaded sentence with no redundant words. It communicates the core action and purpose efficiently, earning full marks for conciseness and 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?

There is no output schema and no annotations to supplement the description. The description does not explain what the report contains, how the result is returned, or any prerequisites. For a diagnostic tool with 5 optional parameters, more contextual detail is needed to fully understand its behavior and output.

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

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

The schema covers 100% of parameters with detailed descriptions for each, including defaults. The description adds no additional parameter semantics, but the schema already provides adequate meaning, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: resolving MAME environment/config paths and reporting which required pieces exist. It uses specific verbs ('resolve', 'report') and a clear resource ('MAME env/config paths'), distinguishing it from sibling tools focused on launching, memory operations, and script execution.

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

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

The description implies a pre-flight configuration check but does not explicitly state when to use it versus alternatives like audit_romset or mame_launch. There is no explicit exclusion or reference to other tools, making the usage context only implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Boot a machine briefly' conveys a temporary side effect, and 'list' suggests a read-only operation. However, it does not discuss potential side effects like log creation, system resource usage, or whether it requires a ROM set or existing MAME session.

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

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

The description is a single, well-structured sentence that is front-loaded with the action ('Boot a machine briefly') followed by the purpose ('list MAME Lua IO-port fields'). It contains no wasted words and is appropriately sized for the tool's function.

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 7 parameters (all with defaults and schema descriptions) and no output schema. The description clearly states the output is a listing of IO-port fields, which is a simple concept. However, it lacks details on the output format or how the listing is presented, and does not mention whether it interacts with session tools. Given the moderate complexity and lack of annotations/output schema, the description is mostly complete but leaves some operational context unaddressed.

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

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

Schema description coverage is 100%, so all 7 parameters are documented with descriptions in the schema. The tool description adds no additional parameter meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Boot a machine briefly and list MAME Lua IO-port fields for input injection.' It uses a specific verb ('boot', 'list') and resource ('MAME Lua IO-port fields'), and distinguishes itself from sibling tools like mame_send_input and mame_exec_lua_live by focusing on enumeration of IO ports.

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

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

The phrase 'for input injection' implies the tool is a precursor to input-related operations, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites stated. The usage context is only implied, not spelled out.

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

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

The description discloses some behavioral details: it runs to a specific tick, snapshots registers and memory at a precise point, and mentions the lockstep primitive. However, it omits side effects, timeout behavior, return values, or any requirements for use. With no annotations, the description carries the full burden but only partially covers it.

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

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

The description is a single dense sentence with no filler or redundant information. It is concise but poorly structured, packing multiple technical details into one run-on sentence that is hard 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?

Given the tool's complexity, the lack of annotations, and no output schema, the description is insufficient. It does not explain the format of the snapshot, how to interpret the output, or any constraints on addresses/registers. More context is needed for an agent to use this 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?

The description provides some parameter context by referring to 'Nth' (likely mapping to the `nth` parameter) and 'memory region' (relevant to `addr` and `len`). However, it gives no explicit mapping, and `timeout` is entirely undocumented. With schema coverage at 0%, the description only partially compensates.

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

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

The description states the core action ('Run to the Nth GAME_TICK ($3A92) and snapshot regs + a memory region'), which is specific and distinguishes it from simple register/memory read tools. However, jargon like 'prologue read', 'lockstep regsA/wramA primitive', and 'entry a7 = SP+60' obscures clarity for general users.

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 usage guidance is provided. The description does not mention when to use this tool versus alternatives like mame_run_frames, mame_get_regs, or mame_read_memory, nor does it indicate prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses the internal steps: waits for $0818 idle, injects clean coin/start edges, confirms GAME_TICK, and explains the C-Chip handshake non-reproducibility. This is substantial behavioral detail, but it lacks return value and error handling 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 two sentences, front-loaded with the main purpose, and every sentence adds meaningful detail. There is no wasted wording.

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 thoroughly explains the tool's behavior, process, and rationale, especially given the lack of an output schema. However, it omits return values and failure modes, which are relevant for an action tool, making it not fully complete.

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

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

The schema has zero parameter descriptions (0% coverage), so the description must compensate. It mentions coin and start conceptually ('inject clean coin/start EDGES'), and credits is implied by name. However, it doesn't specify valid values or what 'clean edges' means in terms of parameter syntax, leaving some ambiguity.

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

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

The description clearly states the tool's function: 'BOOT-AWARE drive to a running game' with a specific sequence (wait for idle, inject coin/start, confirm GAME_TICK). This is a specific verb+resource and distinguishes it from sibling tools like mame_launch (starting) or mame_send_input (raw 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?

It provides clear context for when to use: to reach gameplay after boot, and specifically mentions it is 'Replay-robust where a fixed-frame .inp desyncs'. However, it doesn't explicitly name alternatives or state when NOT to use it, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It does disclose key behaviors: the code runs on the live machine, the variables M and machine are set to manager.machine, and the tool returns the Lua expression's value. However, it does not mention potential side effects, error handling, or whether the operation can modify emulator state, which is relevant for an 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 directly states the action, context, and output. Every word contributes value; there is no fluff or redundancy. This is an ideal level of 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?

This is a simple tool with one parameter and no output schema, so the description is mostly sufficient. It covers the main action and return value, but it lacks details on error behavior, side effects, and when to choose this over sibling Lua tools. Given the potential power of executing arbitrary code, a bit more context would improve completeness.

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

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

The schema has one string parameter 'code' with no description (coverage 0%), so the description must compensate. It partially does by indicating that the code is Lua and runs in a specific environment (M/machine set to manager.machine). Yet it does not explicitly name the parameter or give examples or expected format, leaving room for ambiguity.

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

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

The description clearly states the tool's function with a specific verb ('Run Lua') and resource ('the live machine'), and provides useful context about the execution environment (M/machine = manager.machine) and return value. However, it does not differentiate from sibling tools like run_lua_script or run_lua_inline, so it misses full sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus alternatives. It only states what it does, leaving the agent to guess whether it should use this or the other Lua execution tools in the sibling list. There are no explicit conditions, exclusions, or alternative references.

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. The verb 'Read' explicitly indicates a non-destructive operation, which is useful. However, it does not disclose details about device selection, return format, or any potential side effects, though for a simple read operation this is a minor gap.

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

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

The description is a single sentence that lists the exact registers read, with no filler or unnecessary words. It is well-structured and immediately communicates 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?

The tool has only one parameter and no output schema. The description provides the essential purpose and register list, which is adequate for basic use. However, it lacks explanation of the 'device' parameter and return format, leaving some ambiguity for an agent that needs to invoke it correctly.

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

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

The input schema has one parameter 'device' with a default, but no description is provided. The tool description does not mention the 'device' parameter at all, leaving the agent to infer its meaning from the name alone. Since schema coverage is 0%, the description should compensate, and it fails to do so.

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

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

The description clearly states the tool's function: 'Read all CPU state registers' with explicit register names (D0-D7,A0-A7,PC,SR,USP). It distinctively identifies the resource (CPU state) and is easily distinguished from sibling tools like mame_set_reg (write) and mame_read_memory (memory read).

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 inspecting CPU register state, but it does not explicitly state when to use this tool versus alternatives like mame_set_reg or mame_read_memory. No exclusions or alternative references are provided, leaving the context implied rather than explicit.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses that the MAME process is persistent and lives across tool calls, which is critical stateful behavior. It also mentions headless + bridge mode, adding useful context. It doesn't detail cleanup or failure modes, but for a launch tool this is reasonably transparent.

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

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

The description is two sentences long, immediately states the core purpose, and then the prerequisite. Every sentence earns its place, and there is no wasted text. It is front-loaded with the most important 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 7 parameters, all with schema descriptions, and no output schema. The description explains the essential context: persistence, headless/bridge mode, and that it must precede other live tools. It doesn't describe the return value or how to interact with the session afterward, but given the schema coverage and the tool's role as a setup action, the description is adequately complete.

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

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

Schema description coverage is 100%, so every parameter is already documented with its default and purpose. The tool description itself does not add any parameter-level detail beyond the schema, which is acceptable because the schema does the heavy lifting. Baseline of 3 applies.

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

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

The description clearly states the tool's function: launching a persistent live MAME session with a headless bridge. It distinguishes this tool from siblings by positioning it as a required prerequisite for other mame_* live tools, which is a specific and actionable purpose.

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

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

The description provides explicit usage guidance: 'Required before any other mame_* live tool.' This tells the agent when to use this tool and implies that sibling mame_* live tools should not be invoked before it, effectively excluding alternatives. It is concise and unambiguous.

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 transparency burden. It discloses a prerequisite (stateDirectory) and a follow-up action (run_frames), which adds useful context beyond the tool name. However, it does not detail side effects (e.g., overwriting current state) or failure modes, 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 two short sentences, front-loaded with the core purpose. The parenthetical 'needs stateDirectory' and the follow-up instruction are concise and necessary, earning their place without waste.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the essential context: what it does, a prerequisite, and the next step. It is adequate for an agent to invoke the tool correctly, though it omits edge cases like error handling or state overwriting.

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 only one parameter 'name' with no description (0% schema coverage). The description's phrase 'by name' clarifies that the parameter is the identifier for the save state, which is the essential semantics. It does not add details like name format or where to find valid names, but it is sufficient for a simple string 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's function: 'Load a MAME save state by name.' It uses a specific verb ('Load') and resource ('MAME save state'), and is easily distinguished from siblings like mame_save_state (save) and mame_run_frames (run).

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

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

The description provides clear usage context: it mentions the need for 'stateDirectory' and instructs to 'Apply with a run_frames after.' This gives the agent an explicit sequence to follow, though it does not explicitly name alternatives or exclusions.

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

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

With no annotations, the description carries the burden. It discloses that the paused machine retains readable state, which is valuable. However, it omits other behavior such as whether inputs are ignored, if the pause is instantaneous, or how to resume. Minimal but not misleading.

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

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

A single concise sentence with a parenthetical addition. It is front-loaded with the primary action and wastes no words. Perfectly sized for the tool's simplicity.

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

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

For a tool with no parameters and no output schema, this description sufficiently conveys the action and key implication (state remains readable). It is complete enough for its trivial complexity, though it could mention the associated resume 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?

There are zero parameters, so the schema provides no semantics to clarify. The description doesn't need to explain parameters. Baseline of 4 is appropriate because there is nothing to add.

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 'Pause the live machine' uses a specific verb and resource, clearly distinguishing this from siblings like mame_resume and mame_session_stop. The parenthetical 'state stays readable' further defines the purpose by contrasting with session termination.

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 context is clear: this tool pauses a live machine while keeping state readable. This implies a temporary halt versus stopping the session, though it does not explicitly name alternatives. The state-readability note gives a clear usage signal without formal exclusion 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?

Since no annotations are provided, the description carries the full burden. It only states the core read operation and does not disclose the return format (e.g., hex string encoding), endianness, error handling, or whether the read is non-destructive. The 'hex' parenthetical is ambiguous as to whether it refers to the address format or the output.

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

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

The description is a single, well-structured sentence with no unnecessary words. It front-loads the action and object, making it easy to skim. However, it is perhaps too terse, but for conciseness it scores well.

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 operates within a MAME session context, but the description does not mention this dependency, nor does it explain what the output looks like (critical since there is no output schema). It also fails to specify whether the read is from the CPU's program space only via the space parameter and if there are constraints on alignment or length. Overall, the description is insufficient for an agent to confidently invoke the tool.

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

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

The schema describes three parameters with zero description coverage, and the description does not explain the meanings of addr, len, or space beyond the implied memory block concept. It does not clarify that len is a byte length, addr is an integer starting address, or that space defaults to ':maincpu'. The 'hex' hint is insufficient.

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 a memory block, specifies the hex format, and indicates the target as a device's program space. This distinguishes it from sibling tools like mame_write_memory and trace_memory_access.

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 information is given about when to use this tool versus alternatives, such as trace_memory_access for access pattern tracing or get_regs for register inspection. There is no mention of prerequisites like an active session or when a memory read 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('Resume') but does not explain what happens if the machine is already running, whether it changes any state, or what the effect is. This is a significant gap for a command that modifies machine execution.

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

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

The description is extremely concise and front-loaded with the core action. There is no redundant wording. However, it is so brief that it omits important usage context, so it is not a perfect score.

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

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

Given the tool's simplicity (no parameters, no output schema), the description still falls short by not explaining the machine's required state or the outcome of resuming. It fails to provide enough context for an AI agent to know when it is appropriate to call this tool and what to expect.

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

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

The tool has zero parameters, and the schema is empty (100% coverage). No additional parameter information is needed, so the baseline 4 applies. The description provides sufficient context for the tool's invocation.

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 ('Resume') and the target ('the live machine'), distinguishing it from sibling tools like mame_pause. However, it could be more explicit about the machine's current state (e.g., paused) to fully disambiguate from similar run 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., machine must be paused) or contrast it with mame_pause or mame_run_frames. The usage context is only implied.

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

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

With no annotations, the description carries the transparency burden. It does disclose the pause side effect and return value, which is helpful. However, it does not mention what happens if the emulator is already paused, if N must be positive, or any error behavior, leaving some gaps.

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

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

The description is a single concise sentence that conveys the action, side effect, and return value without waste. It is well-structured and 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?

The tool is simple with one parameter, and the description covers the core behavior and return. However, it lacks context about session requirements, whether the tool resumes from a paused state, or interaction with other MAME controls, making it minimally adequate but not complete.

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

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

The schema already fully describes the parameter 'n' as 'Frames to advance', and the description merely uses 'N' in the same context. Since schema coverage is 100%, the baseline of 3 applies without additional semantic value added.

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

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

The description states a clear action ('Run N frames'), a specific side effect ('pause'), and the return value ('frame number'). This distinguishes it from sibling tools like mame_pause/mame_resume which do not advance frames.

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 is provided. The intent is implied by the name and description, but there is no mention of prerequisites (e.g., session running) or comparison to siblings like mame_send_input or mame_capture_game_tick.

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 states the action and says nothing about overwrite behavior, storage location, failure conditions, or side effects. For a mutation operation, this is a significant transparency gap.

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

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

A single, short sentence that immediately conveys the tool's purpose. Every word earns its place; there is 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?

Given the tool's simplicity (one parameter, no output schema), the description is minimally adequate. However, it omits important context such as whether a game must be running, whether existing save states are overwritten, or how the save state is identified. For a novice agent, this could be insufficient.

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 (name) with zero description coverage. The description adds 'by name', which is almost tautological and does not clarify what the name represents or its format constraints. The parameter semantics are left largely 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 uses a specific verb ('Save') and resource ('MAME save state') with a clear qualifier ('by name'). It unambiguously distinguishes from the sibling tool mame_load_state, which performs the inverse 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: use this when you want to create a save state with a specific name. However, it does not explicitly state when to prefer this over alternatives or mention any prerequisites (e.g., a running MAME session), so the guidance is only implicit.

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

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, but it only states the core action. It does not explain whether the input is a momentary press, a toggle, or requires specific timing, nor does it mention side effects, validation, or return values.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to explaining the tool's purpose, making it highly concise 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?

Despite having only two parameters and no output schema, the description lacks sufficient context for correct invocation. It does not specify how to determine valid field names, what integer values are acceptable, or whether the MAME session must be in a particular state. This is a minimal description for a tool that still has hidden behavioral requirements.

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 gives helpful examples for the 'field' parameter ('Coin 1', 'P1 Right'), but does not explain the meaning of the 'value' integer parameter—whether it is a duration, a bitmask, or a simple on/off state.

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 ('Set') and the target resource ('ioport field value'), with concrete examples ('Coin 1', 'P1 Right'). It distinguishes itself from sibling tools like mame_set_reg and mame_write_memory by focusing specifically on ioport input fields.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites such as requiring an active MAME session or retrieving available ioports first. Usage context is only implied by the tool name and the word 'Set'.

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

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

With no annotations, the description must disclose behavioral traits, but it only mentions 'live' and lists three status fields. It does not state whether the tool is read-only, what output format it returns, or how it behaves without an active session. This lack of disclosure could lead an agent to assume incorrect side effects or error handling.

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 a single nine-word sentence with a useful parenthetical. Every word contributes to conveying the core purpose, and there is no redundancy or filler.

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

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

The tool has no parameters, but also lacks an output schema and annotations, placing the burden on the description. While the three listed fields provide some indication of the status content, the response format and edge-case behavior remain unspecified, making this minimally adequate rather than complete.

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

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

The input schema has zero properties, and the description does not introduce any parameter-related ambiguity. The baseline for zero parameters is 4, and no additional explanation is needed beyond what the schema already specifies.

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

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

The description defines the tool as providing 'Live session status' and lists three example fields: system, frame, paused. Although it lacks an explicit verb like 'get', the noun phrase implies retrieving current state, which is distinct from sibling tools that perform actions such as mame_pause or mame_session_stop.

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 offers no indications for when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or relationships to sibling tools. An agent would not know whether to prefer this over mame_capture_game_tick or run_lua_script for status queries.

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 explaining behavioral implications. It merely says 'Terminate the live MAME session' without disclosing whether termination is destructive, reversible, or what side effects occur. This is insufficient for an agent to understand the impact of invoking it.

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

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

A single clear sentence with no filler. Every word serves a purpose, and the structure is front-loaded with the action verb.

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?

Although the tool is simple, the description lacks essential context about termination behavior. It does not explain what happens to the session, whether it is safe to stop at any point, or how it differs from pausing. Given the many session-related siblings, more detail would help the agent select 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?

The tool has zero parameters, so the schema fully covers the input requirements. Baseline 4 applies since no parameter description is needed, and the description adds nothing beyond the schema, which is acceptable.

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

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

The description clearly states a specific action ('Terminate') on a specific resource ('the live MAME session'). This distinguishes it from sibling tools like mame_pause, mame_resume, and mame_session_status, which all operate on the session but with different 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?

No guidance is provided on when to use this tool versus alternatives such as mame_pause or mame_resume. It does not indicate whether it should be used as a final cleanup step or if it triggers any saving or shutdown procedures.

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 supplied, the description carries the full burden of behavioral disclosure. It only states the action without explaining side effects, reversibility, required emulator state, or error behaviors—critical omissions 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, terse sentence with no wasted words, but it is under-specified. It reads more like a label than a helpful tool description, lacking structure and necessary usage context that would earn 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?

In the absence of annotations and an output schema, the description is drastically incomplete. It does not mention return values, prerequisite emulator states, or how different CPU devices are addressed, leaving the agent with insufficient information for reliable invocation.

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

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

Schema description coverage is 0%, and the description adds no parameter context. While 'reg' and 'value' are self-explanatory names, the 'device' parameter's format/default is undocumented, and the description fails to compensate for the schema's lack of field 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 action ('Set') and the target resource ('one CPU register'), distinguishing it from sibling tools like mame_get_regs (read) and mame_write_memory (memory). However, it omits any mention of the device parameter or scope, falling short of full clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites such as a paused emulator, nor any exclusionary context that would help the agent decide between this and related manipulation 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 must convey behavioral implications. It only states that a hex block is written, but omits side effects such as overwriting program memory, potential crashes, or safety concerns. This is a significant transparency 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, efficient sentence that front-loads the core purpose with no wasted words. It is appropriately concise for a tool with a straightforward operation.

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

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

Given the absence of annotations, output schema, and parameter descriptions, this description is insufficient for safely invoking a memory write tool. It lacks information on required parameters, side effects, and operational context, making it incomplete for the tool's complexity.

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

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

The schema has zero parameter descriptions, and the description only hints at 'hex block' and 'program space,' which partially illuminate the 'hex' and 'space' parameters. However, the 'addr' parameter is undefined, and the exact format of the hex string (e.g., byte order, separator) is not clarified, failing to compensate for the 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?

The description 'Write a hex block to a device's program space' clearly states a specific verb ('write') and resource ('a hex block' to 'program space'), distinguishing it from siblings like mame_read_memory. It is unambiguous about the operation's purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or contextual cues. It does not mention whether this should be used during specific emulation states or how it differs from other write operations like mame_set_reg.

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 full burden. It discloses the core behavior ('echo back') and implies a harmless, read-only operation. It is minimal but sufficient for a simple ping tool, lacking only explicit mention of no 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 concise sentences, front-loaded with the primary action. Every word earns its place with no redundancy.

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

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

For a trivial tool with a single optional parameter and no output schema, the description fully captures purpose, usage, and parameter semantics. No further detail is needed.

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

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

Schema description coverage is 100% for the single 'echo' parameter, and the description adds no additional semantic value beyond saying 'optional payload,' which matches the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Echo back an optional payload.' It is immediately distinguishable from the MAME emulation sibling tools as a connectivity check.

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 second sentence provides explicit usage context: 'Use to verify the MCP bridge is alive.' This tells the agent when to invoke the tool, though it does not list alternative tools or exclusion scenarios.

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

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

The description discloses that execution is headless and that an artifact file can be read back, which is useful. However, it does not mention process timeouts, frame budget safety, or potential side effects on the working directory. With no annotations, this leaves 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, well-structured sentence that front-loads the primary action and includes the key distinction (string vs path). Every word earns its place, with zero redundancy.

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

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

Given the tool has 9 parameters and no output schema, the description provides only minimal context about what happens after execution. It clarifies the core task and optional artifact read-back, but leaves many behavioral and environmental aspects (e.g., defaults, return values when no artifactPath is set) to the schema, which may not be enough for a complex 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 coverage is 100%, so the baseline is 3. The description adds a useful clarification that the lua parameter is a string, not a path, and ties artifactPath to reading back an artifact file. This slightly enhances the schema but is not substantial.

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 caller-supplied MAME Lua source as a string headlessly, distinguishing it from path-based script tools like run_lua_script. The verb 'Run' is specific and the resource is well-defined.

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

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

The phrase 'string, not a path' implicitly tells the agent when to use this tool (inline Lua) versus run_lua_script (file path). 'Headlessly' also suggests use when no interactive session is needed. However, no explicit alternatives or when-not-to-use scenarios 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 carries the full burden of behavioral disclosure, but it only states the basic action. It omits side effects (e.g., whether a MAME process is spawned or modified), safety profile, or any state changes, which is critical for a script 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 with no filler or redundancy. Every word contributes to the core message, making it highly concise and well-structured.

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

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

Despite the tool's complexity (8 params, no annotations, no output schema), the description is too minimal. It fails to convey return behavior, failure modes, or how it interacts with existing MAME sessions, leaving significant gaps for an agent to operate safely.

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

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

The input schema provides descriptions for all 8 parameters (100% coverage), so the baseline is 3. The tool description adds no additional parameter meaning, but the schema already covers the semantics adequately.

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 ('Run'), the resource ('caller-supplied MAME Lua autoboot script'), and the mode ('headlessly'). This distinguishes it from sibling tools like mame_exec_lua_live (live execution) and run_lua_inline (inline script), 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?

There is no guidance on when to use this tool versus alternatives such as run_lua_inline or mame_exec_lua_live. It does not mention prerequisites, expected context (e.g., existing MAME session), or exclusions, leaving the agent to infer usage.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It mentions tracing and reporting a verdict but omits that the tool likely launches MAME, generates Lua scripts (indicated by the dryRun parameter), and does not explain what the 'status verdict' actually is. Side effects and outcome are opaque.

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

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

The description is a single sentence with no filler and is front-loaded with the tool's focus. It efficiently conveys the scope and purpose without 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?

For a tool with 10 parameters, no output schema, and no annotations, this one-sentence description is under-specified. It lacks information about the execution lifecycle, expected return value format, error behavior, and prerequisites, making it inadequate for autonomous 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 100%, so the baseline is 3. The description adds no parameter-specific semantics beyond the generic harness context; it does not explain how parameters like injectPreset or frames relate to the C-Chip tracing.

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

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

The description defines a specific verb ('trace') and a precise resource ('C-Chip accesses' in the $900000-$900FFF range) and adds a report action on the $900803 status. The 'Superman helper' qualifier distinguishes it from generic sibling tools like trace_memory_access.

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

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

The phrase 'Superman helper' implies the tool is for Superman game debugging, giving some context. However, it does not explicitly state when to use this tool over alternatives like trace_memory_access or run_lua_script, so the usage guidance is only implied.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core action but does not mention side effects like launching MAME, writing log files, performance overhead, or what the 'deduped accesses' output actually looks like. This leaves significant behavioral ambiguity for a side-effect-heavy 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 with no wasted words. It efficiently conveys the primary action and output nature, though it is arguably too minimal for such a parametrized tool; that trade-off is better penalized under completeness, not 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?

This is a 12-parameter tool with no output schema and no annotations, yet the description only provides a one-line summary. It fails to explain return values, log format, the effect of dryRun, or how ranges and trackReads interact. A much richer description is needed for an agent to invoke and interpret results correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters. The description adds no parameter-level detail beyond the high-level notion of CPU address ranges and deduped accesses, which is already implied by the tool name and schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Install') with a clear resource ('Lua read/write taps over CPU address ranges') and a distinct outcome ('log deduped accesses'). It clearly distinguishes this from one-shot memory access tools like mame_read_memory/mame_write_memory and from the narrower trace_cchip_superman.

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 mame_read_memory, mame_write_memory, or trace_cchip_superman. The description implies a tracing use case but gives no explicit context, prerequisites, or exclusions.

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