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

No annotations provided, so description carries full burden. It explains behavior: does not change pause state, works whether paused or running, scales linearly (~16ms per frame plus round-trip), and returns error if core doesn't support frameadvance. Also notes RAM behavior after reset.

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?

Well-structured with labelled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence is informative with zero wasted words. Highly efficient and scannable.

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

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

Given a single parameter with full schema coverage and no output schema, the description covers purpose, usage, edge cases (error if core unsupported), performance characteristics, and return format. Nothing missing.

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

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

Only one parameter 'count' with 100% schema coverage. Description adds latency scaling and new framecount formula beyond schema's min and default. Provides practical context: 'New framecount = previous framecount + count.'

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 'Step emulation by exactly N frames' and returns framecount. It distinguishes from siblings like pause/unpause, reset, and save/load state by focusing on frame-precise stepping.

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

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

Explicitly tells when to use (frame-precise automation, animation inspection, after reset) and when not to (prefer save/load state for long jumps). Also suggests combining with press_buttons and notes initialization after hard reset.

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 states 'No side effects — pure read of emulator metadata' and notes that fields return 'unavailable' when not applicable. With no annotations, this fully discloses 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 well-structured with PURPOSE, USAGE, BEHAVIOR, RETURNS sections. Each sentence adds value without redundancy.

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

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

Given no output schema, the description explains the return format and contents in detail. It covers all necessary context for a zero-parameter info 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?

Input schema has no parameters, so schema coverage is 100%. The description adds no parameter info, but baseline for 0 params is 4. Adequate.

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 retrieves ROM name, hash, frame count, memory domains, active domain, and capability map. It distinguishes from sibling tools by being pure info, not a control or write action.

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

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

The USAGE section explicitly says to call after bizhawk_ping, before memory tool calls to confirm domain, and before control actions to check capabilities. It provides clear when-to-use guidance.

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

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

Despite having no annotations, the description fully discloses behavior: no side effects (pure read), and mentions the rare error case when the core doesn't implement memory.getmemorydomainlist. This provides complete transparency for a read-only query.

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

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

The description is concise and well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value, and the information is front-loaded.

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

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

The description is complete for a zero-parameter tool with no output schema. It explains the return format (newline-formatted list) and error conditions, leaving no gaps.

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

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

The tool has 0 parameters, so according to guidelines the baseline is 4. The description doesn't need to add parameter meaning; it confirms no parameters are required.

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 explicitly states the tool's purpose: listing memory domains available on the loaded core. It provides concrete examples for SNES and NES, making it clear what the tool does and how it relates to sibling memory read/write 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 gives clear guidance on when to use the tool: 'Call before any memory r/w tool when you don't know the domain layout.' It also specifies that the returned names are exactly what to pass as the `domain` parameter (case-sensitive), eliminating 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?

Even without annotations, the description clearly labels the tool as destructive ('replaces ALL current emulator state') and warns of crashes from mismatched state files. No contradictions.

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?

Perfectly organized with PURPOSE, USAGE, BEHAVIOR, RETURNS labels. Every sentence is necessary and informative. No fluff.

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

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

Covers purpose, usage, behavior, return value, and error conditions. Given that annotations are absent, the description compensates fully.

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

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

Schema description coverage is 100% and already includes the path meaning and crash warning. The tool description adds minimal new information beyond reinforcing 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 verb 'Restore' and the resource '.State file', and distinguishes from the sibling tools bizhawk_save_state and bizhawk_reset.

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

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

Explicitly mentions counterpoint bizhawk_save_state, provides use cases (undo, bookmark, baseline), and specifies alternative bizhawk_reset for fresh boot.

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 carries full burden. It discloses: modifies emulator run state, Lua bridge keeps polling, other calls still work, returns error if core doesn't expose pause, and no-op if already paused. This is 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?

The description is well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value; no fluff. It is both concise and informative.

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 parameters, no output schema, and the tool's simplicity, the description is complete. It covers purpose, usage, behavior, error handling, and return value, and references sibling tools and capabilities check.

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 no parameters (0 params, 100% coverage). Baseline for 0 params is 4. The description adds no parameter info because none needed, but it does add context about behavior and usage.

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 purpose: 'Pause emulation — freeze game-logic clocks and hold the current frame on screen.' It uses a specific verb and resource, and distinguishes itself from siblings like bizhawk_unpause and bizhawk_frame_advance.

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 says when to use: 'Use before a sequence of memory-inspect / write / screenshot calls when you need a stable game state across calls.' It also provides alternatives: 'Use bizhawk_unpause to resume; use bizhawk_frame_advance to step single frames without leaving pause.'

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 fully covers behavior: no side effects, pure liveness probe, timeout of ~10 seconds, and clear error conditions. No contradictions.

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?

Structured with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS), front-loaded, each sentence adds value, no waste.

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

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

Given no output schema and no parameters, the description is complete: explains purpose, usage, behavior, return value, and error conditions.

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?

No parameters; baseline is 4. Description adds no param info but provides comprehensive tool context beyond the empty 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 explicitly states the purpose: verifying BizHawk Lua bridge connectivity. It uses specific verb 'Verify' and distinguishes from sibling tools by being a liveness probe.

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

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

Explicitly recommends calling at start-of-session before other tools, and specifies success condition. Provides clear context for when to 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?

No annotations are provided, so the description carries full burden of behavioral disclosure. It clearly states that the bridge's main poll loop is BLOCKED during the call, that each screenshot adds ~1 frame of wall-clock, and how the stop_on_memory_change works (records initial value, checks after each frame, aborts on change). Error conditions are listed (missing methods, unknown domain, invalid width, out-of-range address). The description is transparent about all key behaviors.

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 well-structured into sections (PURPOSE, USAGE, BEHAVIOR, RETURNS), and the most critical information is front-loaded. However, it is verbose; some details (like the killer pattern) are repeated in both USAGE and BEHAVIOR sections. While every sentence adds value, compactness could be improved without losing clarity. Still, it remains relatively 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?

Given the tool's complexity (6 parameters, nested objects, no output schema, no annotations), the description is fully complete. It covers purpose, usage, behavior, error conditions, and return format (text summary plus inline images). It explains optional features and their interactions (e.g., screenshot and memory read cadence). No gaps are apparent.

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% (all parameters have descriptions). The description adds substantial value beyond the schema. For example, the `screenshot_every` parameter explains that each screenshot costs ~1 frame and recommends 60 as a good default. The `observe_memory` parameter gives a concrete example for Super Metroid. The `stop_on_memory_change` parameter describes the killer use case. The `frames` parameter includes chunking advice. The descriptions provide meaningful semantics for effective tool use.

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 begins with a clear statement of purpose: 'Play a pre-built sequence of per-frame joypad inputs back-to-back, advancing one frame per element, ENTIRELY SERVER-SIDE in a single bridge round-trip.' It distinguishes itself from siblings (bizhawk_press_buttons and bizhawk_frame_advance) by noting that this tool batches many frames into one call, reducing round-trips. The optional features (screenshots, memory reads, early stop) are also described, making the tool's capabilities very clear.

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 section explicitly advises when to use this tool ('whenever you have ≥10 frames of inputs to play in order') and contrasts with looping the two sibling tools, which would cost 2N round-trips. It also recommends chunking for sequences over ~200 frames. However, it does not explicitly state when NOT to use it (e.g., for very short sequences it might be overkill), though the recommendation for ≥10 frames implies exclusion for shorter sequences. The guidance is clear and actionable.

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 fully covers behavior: sets input for exactly one frame, then reverts to human input, silently ignores invalid button names, returns a status line, and describes error conditions. No contradictions.

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?

Well-structured with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Front-loaded with purpose. Slightly verbose due to empirical example, but each part serves a purpose.

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

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

Given no annotations and no output schema, the description is remarkably complete: covers purpose, usage patterns, behavioral details, return format, error handling, and button name guidance. No gaps 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?

Schema covers both parameters with 100% description coverage. The description adds minimal extra meaning but includes an example for buttons and clarifies the player default. Could be slightly more detailed about button name variability.

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 'set joypad button state for one player for exactly the next emulated frame.' It provides a specific verb-resource-scope and distinguishes from siblings like bizhawk_frame_advance by clarifying frame-level granularity.

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

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

Explicitly tells when to use (drive games) and when not to (avoid single press+multiple frame_advance). Provides the correct interleaving pattern and explains how to release buttons. Includes empirical verification.

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?

Despite no annotations, the description fully discloses behavioral traits: no side effects (pure read), byte ordering details (reads low byte at address, high byte at address+1, little-endian combination), and error conditions for missing domain, out-of-bounds, or missing core capability. This provides complete transparency 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?

Structured with bold headings for clear skimming. Every sentence is relevant, though slightly wordy. Could be shortened by removing redundant examples, but remains efficient for the information conveyed.

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

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

No output schema, but description specifies exact return format. Covers all essential aspects: purpose, usage, behavior, errors, and integration with sibling tools. Complete for a simple read tool with two parameters.

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 100% coverage with detailed descriptions. The description adds value by explicitly stating the little-endian interpretation (not in schema) and the independence of bus addresses (already in schema but reinforced). A small but meaningful addition 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?

Description clearly states verb ('Read'), resource ('unsigned 16-bit little-endian value'), and context ('from emulator memory at the given address'). Distinguishes from siblings by explicitly naming alternatives (bizhawk_read8, bizhawk_read32, bizhawk_read_range) with specific use-cases, making the tool's purpose unmistakable.

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

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

Explicitly states when to use ('for 16-bit fields') and when not to use, listing exact sibling tools for other bit widths and endianness. Includes error conditions and domain selection guidance, leaving no ambiguity about appropriate invocation.

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 fully covers behavioral traits: it declares 'No side effects — pure read', explains endianness handling (LSB at address, MSB at address+3), and lists error conditions (domain missing, address out of bounds, core lacking capability). No contradictions with absent 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 structured into clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) with no redundant sentences. Every sentence provides unique, useful information, earning its place. It is appropriately sized for a tool of this complexity.

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 an output schema, the description fully explains the return value format and error conditions. It covers all relevant aspects for a read tool: side effects, endianness, address semantics, domain usage, and alternatives. No gaps identified.

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

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

Schema coverage is 100% and already describes parameters well. The description adds value by explaining that offsets are per-domain and independent of system bus addresses, and gives examples of domain names per system. It also clarifies the return format, which the schema does not cover.

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 32-bit little-endian value from emulator memory. It distinguishes itself from siblings by explicitly referencing read8/read16 and read_range for other use cases, providing a clear, specific verb+resource.

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 (32-bit fields) and when not to (8/16-bit reads, big-endian, unaligned multi-word), naming alternative tools (bizhawk_read8/16, bizhawk_read_range). This provides clear guidance for tool 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, the description fully covers behavior: 'No side effects — pure read. Reads work the same way whether emulation is paused or running.' It also lists error conditions for missing domain, out-of-range address, or missing core functionality.

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 well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and every sentence adds value. It is concise without being terse.

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 includes a RETURNS section with an example format and explains error conditions. It is complete for a simple read tool, covering all necessary context.

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

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

Schema description coverage is 100%, and the description does not add new information beyond the schema's thorough parameter descriptions. Baseline 3 is appropriate as it doesn't compensate further.

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 starts with 'PURPOSE: Read an unsigned 8-bit byte from emulator memory at the given address.' This is a specific verb and resource, clearly distinguishing from sibling tools like bizhawk_read16, bizhawk_read32, and bizhawk_read_range.

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 section explicitly states 'Use for single-byte status flags, counters, and 8-bit fields' and advises using bizhawk_read16/read32 for larger values or bizhawk_read_range for spans, providing clear when-to-use and when-not-to-use guidance.

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

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

States 'No side effects — pure read' and lists three error conditions (unknown domain, length out of range, address+length exceeds domain). With no annotations, this provides good behavioral transparency, though it omits potential rate limits or other edge cases.

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?

Description is structured with clear labels (PURPOSE, USAGE, BEHAVIOR, RETURNS) and every sentence adds value. It is concise, front-loading key information, and avoids 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, the description explains the return format (header + hex bytes) and error conditions. It also mentions the workflow context. However, it lacks an explicit example of the return string, which would aid 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?

Input schema has 100% coverage with descriptions for address (0-based per-domain), length (1-4096 with hard cap), and domain (optional with examples and error condition). Description adds context beyond schema, such as the per-domain offset meaning and the chunking limit.

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 'Read a contiguous range of bytes from emulator memory' with specific verb and resource. Distinguishes from siblings by noting usage for >4 bytes and references the two-snapshot workflow, making purpose unmistakable.

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

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

Explicitly states when to use: for >4 bytes to avoid multiple round-trips and max 4096 bytes per call with chunking advice. Implies when not to use by contrasting with single-byte reads, but does not explicitly name sibling tools like bizhawk_read8/16/32 as 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?

Since no annotations are provided, the description fully discloses the destructive behavior, detailing exactly what changes: RAM contents become indeterminate, CPU resets, framecount resets, joypad clears, audio/video state discarded. It also notes that the ROM stays loaded and unsaved progress is lost, and mentions error conditions if the core lacks reboot_core.

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 well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and is concise, with each sentence adding value. No extraneous text.

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

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

Given the tool's complexity and lack of output schema, the description covers all necessary aspects: purpose, usage, behavioral details, return value, and error handling. It is complete for an agent to understand and 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?

The input schema has no parameters (100% coverage), so the description does not need to add parameter information. The baseline of 3 is appropriate as it does not contribute additional parameter semantics 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's purpose: 'Reset the loaded core — equivalent to a hard reset (power cycle) of the emulated console.' It distinguishes itself from the sibling tool bizhawk_load_state, which is used for returning to a saved state.

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 guidelines: 'Use to start fresh from boot.' It also tells when not to use it and suggests an alternative: 'To return to a specific known-good point instead of boot, use bizhawk_load_state with a previously saved state file.'

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?

Despite no annotations, the description fully discloses destructive behavior (overwrites without prompt), compatibility constraints (bound to exact ROM and core version), and error conditions (parent directory missing, unwritable path, core not supporting save).

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 well-structured with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence is informative and necessary, none wasted.

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

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

For a single-parameter tool without output schema, the description is complete. It covers output format, error conditions, and critical behavioral details like version binding, leaving no gaps.

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

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

Schema coverage is 100%, but the description adds significant value: clarifies that extension is convention not required, parent directory must exist, and file is overwritten without prompt. This context goes beyond the schema's property description.

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

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

The description clearly states the verb 'save', the resource 'entire emulator state', and the target 'file at given path'. It distinguishes itself from the sibling 'bizhawk_load_state' by explicitly mentioning the companion tool for restoration.

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 scenarios: 'rollback point before risky writes', 'bookmark interesting game states', 'share repro states'. It also differentiates from slot-based systems by noting BizHawk's path-based API.

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?

Thoroughly discloses destructive behavior (overwrites file without prompt), error conditions (missing parent dir, unwritable, unsupported core), and suggests checking capabilities first. With no annotations, the description fully informs the 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?

Well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value, no redundancy. Concise yet comprehensive.

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 1-parameter tool with no output schema, the description covers purpose, usage, behavior, and return format completely. No gaps remain.

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

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

Schema coverage is 100%, but the description adds significant value: absolute path requirement, examples, parent dir must exist, overwrite behavior. This fully compensates and enriches 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 saves a PNG screenshot to a given file path. It is the only screenshot tool among siblings, so differentiation is not needed but the purpose is explicit.

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

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

Provides clear usage context: capturing game state, and advises to pause/advance/load state first. Mentions explicit path requirement. Lacks explicit when-not-to-use, but the guidance is sufficient and context-rich.

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 behavior. It states it modifies run state, may error if core lacks feature (with actionable check), is no-op when not paused. Sufficient for a state-modifying 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?

Four clearly labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) with minimal yet complete information. No filler.

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

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

Given no parameters, no output schema, and no annotations, description covers purpose, usage, behavior, return value, error conditions, and prerequisites. Complete for this 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?

Input schema has 0 parameters with 100% coverage; baseline 3. Description adds no parameter details, but that's acceptable as there are none to describe.

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

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

Clear verb+resource: 'Resume emulation after a pause'. Distinguishes from sibling bizhawk_frame_advance by stating its specific use case. No ambiguity.

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

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

Explicitly states when to use ('after a paused inspection sequence') and when not to ('use bizhawk_frame_advance for frame advance'). Names alternative sibling tool directly.

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

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

The description thoroughly discloses behavior: it is destructive ('overwrites two bytes... with no undo'), notes no mediation, lists all error conditions, and explains byte ordering. Since no annotations are provided, this fully compensates.

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 well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value, no redundancy, and it is appropriately concise for the complexity.

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 no output schema, the description includes a RETURNS section specifying exact output format. Schema coverage is 100%, no annotations, but the description covers all necessary behavioral and error information. The tool fits clearly among siblings.

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

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

The input schema already covers all three parameters with clear descriptions (100% coverage). The description adds context about little-endian ordering and byte placement, but does not significantly extend beyond the schema. Baseline 3, slightly elevated due to integrated behavioral notes.

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 explicitly states the purpose: 'Write an unsigned 16-bit little-endian value to emulator memory at the given address.' It clearly distinguishes from sibling tools by referencing bizhawk_write8, bizhawk_write32, and others.

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: 'Use for 16-bit cheats and pokes (HP, score, coordinates).' It also specifies alternatives for related tasks, such as using bizhawk_write8 for single bytes, bizhawk_write32 for 32-bit, etc.

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 fully discloses destructive behavior (overwrites four bytes, no undo), error conditions, and that it bypasses MBC/mapper/DMA. Provides actionable guidance (save state first).

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?

Well-structured with clear headings (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence is informative and front-loaded with purpose. 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?

Comprehensive coverage of purpose, usage, behavior, error conditions, and return format. Schema handles parameter details, leaving description to address agent decision-making needs fully.

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 detailed descriptions. The tool description adds practical usage examples (timestamps, large counters) and reinforces error conditions, but does not add significant new semantic detail beyond what 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 writes a 32-bit little-endian value to emulator memory. It distinguishes from siblings like bizhawk_write8 and bizhawk_write16 by specifying bit width and endianness.

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

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

Explicitly recommends use for 32-bit cheats and pokes, and advises using alternative tools for 8/16-bit values or big-endian layouts. Includes when to avoid (e.g., need for rollback) and suggests snapshotting.

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 carries full burden. Clearly states the tool is destructive with no undo, bypasses MBC bank switches and cartridge mapper side-effects, returns error conditions (unknown domain, out of range, invalid value), and works regardless of emulation 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?

Description is well-structured with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and front-loaded. Each sentence adds value, though it could be slightly more compact without losing 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 no output schema and no annotations, the description fully covers purpose, usage guidelines, behavioral traits, error conditions, and return format. It is sufficiently complete for an agent to select and invoke 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?

Input schema covers all 3 parameters with full descriptions (100% coverage). Description adds some context (e.g., address is per-domain, independent of system bus addresses) but mostly echoes schema. Baseline 3 is appropriate since schema already does heavy lifting.

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

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

Description explicitly states it writes a single unsigned byte to emulator memory at a given address, with concrete examples like 'give a player N lives, unlock a flag, set a counter'. It clearly distinguishes from sibling tools like bizhawk_write16, bizhawk_write32, bizhawk_write_range, and bizhawk_load_state.

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

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

Provides explicit when-to-use (single-byte cheats, debug pokes, game-state mutations) and when-not-to-use (prefer bizhawk_write16/write32 for larger values, bizhawk_write_range for spans, bizhawk_load_state for cart save RAM). Names alternative tools directly.

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

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

Despite no annotations, the description discloses destructive nature ('overwrites N bytes with no undo'), bypassing of MBC/mapper/DMA, sequential writing, and specific error conditions. This fully informs the agent of behavioral traits.

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 well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS), front-loaded with key information. Every sentence is informative and concise without redundancy.

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

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

For a tool with no output schema and no annotations, the description covers purpose, usage scenarios, behavioral details, error conditions, return format, and constraints. It leaves no critical gaps for an AI agent to correctly 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?

Input schema already provides 100% coverage with detailed descriptions for all 3 parameters. The description adds value by explaining the 4096-byte limit, batching strategy, and domain optionality usage, though it doesn't introduce meaning 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 'Write a contiguous byte sequence to emulator memory starting at the given address', which is a specific verb+resource pairing. It distinguishes itself from siblings by referencing 'looping bizhawk_write8' and the ~4 byte threshold, 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?

Explicitly says 'Use whenever you're seeding more than ~4 bytes' and contrasts with 'bizhawk_write8' and 'bizhawk_load_state' for alternative scenarios. Also provides batching guidance for writes exceeding 4096 bytes.

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