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

Discloses key behaviors: modifies breakpoint table, persistence until removal or restart, error on non-executable memory. No annotations provided, so description carries full burden. Could mention whether duplicate addresses are handled, but overall adequate.

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

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

Four short sections with clear labels (PURPOSE, USAGE, BEHAVIOR, RETURNS). No redundant sentences; every line provides unique value.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers purpose, usage, behavior, return format, and error case. Missing details like duplicate handling or disabling momentarily, but still complete enough for successful 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 covers address with description, but description adds context: 'Usually in user RAM (0x08800000+) or kernel RAM.' This extra guidance helps the agent select correct addresses.

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

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

Clearly states verb+resource: 'Add a CPU execution breakpoint' with specific location (PSP physical address) and effect (emulation halts when PC reaches). Distinguishes from siblings like ppsspp_breakpoint_list and ppsspp_breakpoint_remove.

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 describes when to use ('For RE work and HLE intercepts') and suggests combining with specific sibling tools (ppsspp_resume, ppsspp_get_registers), providing clear usage context.

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

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

Declares 'BEHAVIOR: No side effects — pure read.' Without annotations, the description fully covers behavioral traits, assuring the agent of safe, read-only operation.

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

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

Well-structured with clear section headers (PURPOSE, USAGE, BEHAVIOR, RETURNS). Each of the four sentences serves a distinct purpose 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 simple list tool with no parameters and no output schema, the description covers purpose, usage, behavior, and return format. Could mention sibling distinction, but overall sufficient.

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

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

Input schema has zero parameters (100% coverage). Description adds no parameter details, but no parameters exist. Baseline of 4 for zero-parameter case 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?

Description explicitly states 'List all currently-set CPU execution breakpoints', using specific verb and resource. Clearly distinguishes from sibling tools like ppsspp_breakpoint_add and ppsspp_breakpoint_remove.

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 instructions: 'Inventory before bulk-removing, or sanity-check what's set.' While no explicit alternatives or when-not-to, the context makes it clear it's for listing only.

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 idempotent behavior for non-existent breakpoints and states it modifies the breakpoint table, which is beyond what annotations would provide.

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

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

Three concise sentences structured with 'PURPOSE', 'USAGE', 'BEHAVIOR', 'RETURNS'. No unnecessary words, 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?

Simple tool with one parameter and no output schema. Description covers purpose, usage, behavior, and return value completely. 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?

Single parameter 'address' with 100% schema coverage. Schema description already explains it as 'PSP execution address'. Description adds no additional semantic value beyond the schema.

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

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

Description clearly states the verb 'Remove' and resource 'CPU execution breakpoint'. It distinguishes from siblings like ppsspp_breakpoint_add and ppsspp_breakpoint_list.

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

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

Explicitly says 'Clean up breakpoints when done debugging' and suggests using ppsspp_breakpoint_list to remove all. 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?

With no annotations provided, the description fully covers behavior: 'No side effects — pure read' and 'Returns 'no game loaded' fields if PPSSPP is at the home menu / not currently emulating.' This completely informs the agent of safety and outcomes.

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 with 'PURPOSE:', 'USAGE:', 'BEHAVIOR:', 'RETURNS:' sections, making it easy to scan. It is concise with no wasted words, and the most critical information comes first.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description completely covers purpose, usage, behavior, and return format. It leaves no ambiguity about what the tool does or when to use it.

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

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

There are no parameters, so the description adds value by explaining the return format and field names (Title, Disc ID, Version, run state). With 100% schema coverage, a baseline of 3 applies, but the extra detail on return fields justifies a 4.

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

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

The description clearly states the tool's purpose: 'Get the loaded game's title, disc ID, and version, plus PPSSPP's run state.' It uses specific verbs and resource names, and distinguishes itself from sibling tools like ppsspp_get_registers by focusing on game metadata and emulation 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 explicitly advises to 'Call after ppsspp_ping to learn what game is loaded and whether emulation is currently running or stepping.' This provides clear context and sequencing relative to a sibling tool, and mentions the edge case of 'no game loaded' at the home menu.

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 behavior: no side effects, pure read, and notes that the snapshot timing depends on emulation state (paused vs running). No contradictions with annotations as none are provided.

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

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

The description is well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and every sentence adds unique value. It is slightly verbose but balanced given the need to cover multiple aspects for a tool with no annotations.

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, the description fully covers purpose, usage guidance, behavioral transparency, and return format. It is complete and leaves no significant gaps for an AI agent to understand invocation and expected 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 input schema has no parameters, so baseline is 4. The description adds value by explaining the return format (multi-line with grouped registers), which is relevant for understanding the output even though it is not parameter documentation.

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 all MIPS Allegrex CPU registers, specifying GPR, FPU, and special registers. It uses a specific verb+resource and distinguishes from sibling memory-reading tools like ppsspp_read32 and ppsspp_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 description provides explicit usage contexts such as reverse engineering and debugging, including calling convention details for argument inspection. It offers clear guidance but does not explicitly state when not to use it or list alternative sibling tools for similar tasks.

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?

Details that it modifies emulator run state, pauses MIPS CPU, rendering may continue at last frame, and is idempotent. Since no annotations exist, the description fully covers 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?

Well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value; 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?

For a simple pause tool with no output schema, the description explains the return value ('Emulation paused') and provides all necessary context. Complete and sufficient.

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

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

No parameters; baseline is 4 as per rules. No additional explanation needed.

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

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

Description clearly states 'Pause PSP emulation' with a specific verb and resource, and distinguishes from siblings like ppsspp_resume and ppsspp_step by mentioning 'stepping mode'.

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 when to use (before memory inspects for stable state), notes that memory tools still work, and directs to ppsspp_resume for continuation. Provides clear usage context.

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

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

The description details that the tool has no side effects, calls the 'version' event, and times out after ~10 seconds under conditions like PPSSPP not running or remote debugger disabled. It also mentions the prerequisite 'Allow remote debugger' setting. With no annotations provided, 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 structured with clear labels (PURPOSE, USAGE, BEHAVIOR, RETURNS), is very concise, and front-loads the essential information. Every 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 adequately explains the return format. It covers purpose, usage, behavior (including timeout), prerequisites, and return value. With 0 parameters, no further detail is needed; the description is complete for this tool's simplicity.

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

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

The input schema has 0 parameters, so schema_description_coverage is 100%. The description adds value by explaining what the tool returns ('Single line 'pong (PPSSPP VERSION)''), exceeding the baseline expectation for zero-parameter tools.

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

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

The description clearly states the tool's purpose: 'Verify that the PPSSPP WebSocket debugger is reachable and responding.' This is a specific verb and resource, and it distinguishes the tool from sibling tools like ppsspp_get_info or ppsspp_breakpoint_add, which serve different purposes.

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

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

The description explicitly says 'Call once at start-of-session before any other tool calls; if it succeeds, the WebSocket handshake worked.' This provides clear guidance on when to use the tool and what the result implies.

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, but the description fully explains the behavior: the emulator queues the press internally, the tool returns immediately, and the button is auto-released after the specified duration. Also mentions error handling for unrecognized button names.

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 uses a clear, structured format (PURPOSE, USAGE, BEHAVIOR, RETURNS) and is concise with no wasted words. All 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?

Given the low complexity (2 parameters, no nested objects, no output schema), the description is complete. It covers 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?

Input schema covers 100% of parameters with descriptions. The description adds value by mentioning the return message format, which is not in the schema, and provides context about the button names without repeating the enum list.

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 presses a PSP button for a fixed number of frames and auto-releases. It distinguishes from the sibling tool ppsspp_press_buttons by specifying that the press is discrete and temporary.

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 to use for discrete actions and to use ppsspp_press_buttons for longer holds. Provides concrete examples (skipping cutscene, confirming menu).

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 fully discloses the persistent button state behavior, noting that buttons stay held until changed, which goes beyond the missing annotations. It also lists case-sensitive button names and 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 description is well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and every sentence adds essential information 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 single-parameter tool with no annotations or output schema, the description is fully complete, covering purpose, behavior, parameter details, return format, and error handling.

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 parameter is well-documented in the schema, but the description adds value by listing valid button names, giving an example, and noting case-sensitivity, earning a score above the baseline of 3.

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

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

The description clearly states the purpose as 'Set the PSP joypad button state' and distinguishes it from one-frame-only schemes, making it specific and actionable.

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 explicit when-to-use guidance (drive games with input) and contrasts with the sibling ppsspp_press_button for timed one-shots. It also explains how to release all buttons.

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

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

Discloses no side effects ('pure read'), error condition ('Returns an error if address+2 exceeds valid memory region'), endianness ('PSP is little-endian'), and return format ('Single line 'ADDR_HEX: VAL_DEC (0xVAL_HEX)''). With no annotations, the description fully addresses 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 concise with clear section headers (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds unique value, and there is no redundancy or unnecessary 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?

For a simple one-parameter read tool with no output schema, the description covers behavior, errors, endianness, return format, and memory layout hints. It is fully complete for an AI agent to select 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?

Schema description coverage is 100% and includes memory layout details. The description adds extra context by reiterating endianness and return format, which enhances understanding beyond the schema. However, the schema already provides substantial information, so a baseline of 3 is appropriate; the extra value justifies a 4.

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

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

The description clearly states the tool reads an unsigned 16-bit little-endian value from PSP memory at a given physical address. It uses a specific verb ('read'), resource ('PSP memory'), and data type, and distinguishes from siblings by naming alternative tools for different sizes.

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 for 16-bit game-state fields' and provides direct alternatives: 'For single bytes use ppsspp_read8; for 32-bit use ppsspp_read32; for arbitrary byte spans use ppsspp_read_range.' This clearly indicates when to use this tool versus others.

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 handles burden. Clearly states no side effects, little-endianness, and error condition when address+4 exceeds memory.

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 PURPOSE, USAGE, BEHAVIOR, RETURNS. Four lines, no fluff, 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?

Single parameter, no output schema, but description covers return format and error condition. Complete for the tool's simplicity.

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

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

Schema has 100% coverage, but description adds value by explaining memory layout and address ranges, beyond the schema's 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?

Clearly states reading a 32-bit unsigned little-endian value from PSP memory. Distinguishes from siblings by specifying 32-bit fields and mentioning alternatives for other sizes.

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 when to use this tool (32-bit fields) and when to use alternatives (ppsspp_read8/read16 for smaller, ppsspp_read_range for spans).

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 fully carries burden. Clearly states no side effects (pure read), and that it returns an error if address is invalid. Also describes the return format.

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?

Very concise with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) that front-load key information. Every 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?

For a simple read tool with one parameter and no output schema, description covers purpose, usage context, behavioral traits, return format, and error handling. 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?

Schema provides detailed description of the address parameter (100% coverage). Description adds further context on PSP memory layout (user RAM, kernel RAM, VRAM, etc.), enhancing understanding 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?

Clearly states it reads an unsigned 8-bit byte from PSP memory at a physical address. Distinguishes from siblings by mentioning alternative tools for other data widths (ppsspp_read16/read32) and ranges (ppsspp_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?

Explicitly states when to use: for single-byte fields, counters, etc. Provides alternatives for other scenarios, e.g., for 16/32-bit values or spans.

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: no side effects ('pure read'), internal decoding/formatting, error conditions for invalid addresses, and no hard size limits but a recommended cap. Since no annotations are provided, the description carries full burden and meets it exceptionally.

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-organized with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS), uses no redundant words, and is appropriately concise for the complexity of the tool.

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

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

Despite no output schema, it fully describes the return format and error conditions, covers the tool's scope and limitations, and provides all necessary context for correct invocation.

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

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

The input schema already has 100% coverage with detailed descriptions for both parameters. The tool description adds practical guidance (e.g., memory layout, recommended size limit) but does not introduce critical semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description explicitly states 'Read a contiguous range of bytes from PSP memory and return as a hex dump' and differentiates from sibling typed-read tools by noting its use for more than ~4 bytes, making it a specific verb+resource with clear distinction.

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

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

It clearly advises using this tool for reads of more than ~4 bytes to avoid multiple round-trips and recommends a practical size limit (≤16 KiB). It does not explicitly exclude use cases for smaller reads, but the advice implies the 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?

Given no annotations are provided, the description fully covers behavioral traits: pure read with no side effects, reads until null terminator, decodes UTF-8, and returns errors for invalid memory or string running past valid memory. This is comprehensive and meets the burden fully.

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, using labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) to front-load key information. Every sentence adds value 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?

The description is complete for a simple read tool: it explains input (single address), behavior (null-terminated, UTF-8), output format (single line), and error cases. No output schema exists, but the description covers return value adequately.

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

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

The input schema already provides 100% coverage with a detailed description of the 'address' parameter, including PSP memory layout. The tool description does not add new semantic information beyond what the schema provides, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool reads a null-terminated UTF-8 string from PSP memory, with specific use cases like in-game text and file names. It distinguishes itself from sibling tools that read raw bytes (e.g., ppsspp_read8/16/32) by its focus on string extraction.

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 the tool (in-game text, character names, dialogue, file names) and mentions the termination condition (stops at first 0x00 byte). However, it lacks an explicit statement of when not to use it or which alternative tool to use for non-string data, though the sibling context implies this.

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?

Describes destructiveness in detail: 'RAM contents cleared, CPU returns to game entry point, framecount/game-state lost. The ISO/EBOOT stays loaded.' Since no annotations exist, this fully covers behavioral disclosure.

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

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

Three sentences covering purpose, usage, and behavior, plus return note. Each sentence earns its place; front-loaded with clear labels.

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 zero parameters and no output schema, the description covers all necessary information: purpose, when to use, destructive behavior, and return value. Complete for the tool's simplicity.

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

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

No parameters exist (0 params, 100% coverage). Baseline is 4; description adds no param-specific info but none needed.

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

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

The description clearly states the purpose: 'Reset the loaded PSP game — equivalent to soft-resetting the console.' This is specific and distinguishes from sibling tools like pause/resume.

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: 'start fresh from the game's intro.' Also explains alternative for savestate loading, providing clear context and 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?

Describes modifying emulator run state, idempotency (no-op if already running). No annotations provided, so description carries burden. Could mention if any side effects, but likely none needed.

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?

Very concise, structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). Every sentence adds value, 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?

Fully covers tool's purpose, usage, behavior, and return value. No missing information given zero parameters and no output schema.

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

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

Zero parameters, schema coverage 100%. Description adds no parameter info but baseline 4 for zero params 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?

Description clearly states it resumes PSP emulation from a paused/stepping state, using a specific verb and resource. It distinguishes from siblings by mentioning ppsspp_pause and ppsspp_step as alternatives.

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

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

Explicitly identifies as counterpart to ppsspp_pause, advises use after paused inspection, and suggests ppsspp_step for frame stepping. Provides 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?

The description discloses key behaviors: pauses CPU during capture, resumes unless already paused, returns error if no game loaded, and that the 'output' source can crash PPSSPP but MCP auto-reconnects. Since no annotations are provided, the description carries the full burden and meets it fully.

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 with clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and front-loads the purpose. Every sentence adds unique value without redundancy. Length is appropriate for a one-parameter tool.

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

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

Given no output schema, the description specifies the return format (text confirmation + inline PNG). It covers all aspects: purpose, source options, side effects, error cases, and post-capture behavior. Sufficient for an agent to select and invoke 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 provides 100% coverage with enum values, but the description adds significant value: explains the technical difference (GPU render target vs composited output), notes native resolution for render, and gives crash context for output. This exceeds schema detail.

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

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

The description clearly states the tool captures a PNG screenshot of the PSP framebuffer, with specific verb 'capture' and resource 'framebuffer'. It distinguishes between 'render' and 'output' sources, and differs from sibling tools (no other screenshot tool) by focusing solely on visual capture.

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

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

The description provides explicit guidance: 'Prefer 'render' unless you specifically need the post-processed image.' It warns against using 'output' on certain games due to crash risk, and explains the default behavior. There are no alternative screenshot tools among siblings, so it fully addresses when to use this tool.

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

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

Without annotations, the description discloses key behavioral traits: 'Modifies emulator analog input. State persists until updated.' and describes the return string. This is adequate for a simple stateful setter, though rate limits or side effects are not mentioned.

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 sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and is concise, covering all necessary points without extraneous words. A minor improvement could be removing redundant phrasing.

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

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

Given the simple nature of the tool, complete schema coverage, and no output schema, the description fully addresses usage, behavior, and return format. The context of siblings (all emulator commands) is clear, and no further details are needed for an AI agent to use the tool correctly.

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

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

The input schema has 100% description coverage, but the description adds useful context: it explains the coordinate system with examples like '(0,0) neutral, (1,0) full right, (0,-1) full up' and notes that 'right' is reserved. This goes beyond the schema's min/max and enum 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 'Set the PSP analog stick state' and specifies that it handles one of left/right, noting the PSP only has one stick natively. It differentiates from sibling tools like ppsspp_press_button by explaining it is for analog input needed in games.

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

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

The description explicitly says 'Drive games that need analog input — character movement, camera control.' It also clarifies that 'right' is reserved for forward-compat, guiding selection between sticks. However, it does not explicitly contrast with digital press tools or state when not 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 provided, so description carries full burden. It discloses that it modifies emulator run state, executes one instruction, returns to stepping mode, and errors if not in stepping mode. Return format is also specified.

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?

Front-loaded with PURPOSE and USAGE sections. Every sentence is valuable; no waste. Extremely 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?

Covers all necessary context: stepping mechanism, relation to frame-advance, prerequisites, return value. No output schema exists but return is described. Complete for a zero-parameter 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?

No parameters exist, so baseline is 4. The description does not need to add parameter details, and the purpose is fully covered.

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

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

The description clearly states the purpose: stepping the MIPS CPU by one instruction (cpu.stepInto). It uses specific verbs and resources, and distinguishes from sibling tools like ppsspp_resume (frame advance) and ppsspp_pause (enters stepping mode).

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

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

Explicit usage guidance: set a breakpoint then step, with clear note that it is not a frame-advance. It also states when to use alternatives (set breakpoint and ppsspp_resume) and prerequisites (emulation must be in stepping mode via ppsspp_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?

The description highlights destructive behavior ('overwrites two bytes with no undo'), explains the little-endian byte order, and documents error conditions (address+2 out of bounds, value > 65535). Since no annotations are provided, this disclosure is critical and thorough.

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

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

The description is organized into clear sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) and uses concise language. Every sentence provides necessary information 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 the tool's simplicity (2 parameters, no output schema), the description covers all essential aspects: purpose, usage guidance, behavioral details, error handling, and return format. 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%, so the baseline is 3. The description adds value by explaining endianness context (low byte at address, high at address+1) and linking the value range to the error condition. This is helpful beyond the schema's parameter 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 ('Write an unsigned 16-bit little-endian value'), target resource ('PSP memory'), and distinguishes from siblings by specifying the bit width and endianness. Sibling references in the usage section confirm this 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?

Explicitly tells when to use this tool ('16-bit cheats and pokes') and when not ('For single bytes use ppsspp_write8; for 32/larger use ppsspp_write32/write_range'), providing direct alternatives.

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

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

With no annotations, the description fully covers behavior: it declares 'DESTRUCTIVE: overwrites four bytes with no undo', mentions endianness, and error conditions for address+4 and value bounds.

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 headers (PURPOSE, USAGE, BEHAVIOR, RETURNS) and every sentence adds essential information. No fluff.

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

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

Given no output schema, description adequately describes the return format. Covers purpose, usage, behavior, errors, and return. Complete for a 2-parameter 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 already covers both parameters (100% coverage). Description adds context like little-endian and error condition 'address+4 exceeds valid memory', but the schema already defines value max. Slight enhancement.

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 'Write an unsigned 32-bit little-endian value to PSP memory' – a clear verb+resource. It also distinguishes from similar tools by naming ppsspp_write8, write16, and write_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?

Provides explicit usage guidance: 'Use for 32-bit cheats and pokes — timestamps, large counters, pointers.' Then gives clear alternatives for 8/16-bit and spans, fulfilling both when-to-use and when-not-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?

Discloses destructive behavior, direct memory write, and error conditions. No annotations provided, so description bears full burden; it covers key 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?

Well-structured with labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS). No unnecessary words. Front-loaded key information.

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

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

Provides return format and error conditions. No output schema, so description compensates adequately. Could mention potential impact on emulator state, but sufficient for typical use.

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

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

Schema coverage is 100%, baseline 3. Description adds context for the address parameter (memory layout, acceptable ranges) beyond schema. Value parameter is straightforward.

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

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

Clearly states that it writes an unsigned byte to PSP memory at a physical address. Distinguishes from sibling tools by mentioning write16, write32, and write_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?

Explicitly states use cases (single-byte cheats, debug pokes, game-state mutations) and provides alternatives for other widths or ranges.

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 full burden. It explicitly states 'DESTRUCTIVE: overwrites N bytes with no undo' and 'Direct memory write.' It also describes error conditions: 'Returns an error if address+N exceeds valid memory or any byte value is outside 0-255.' This fully discloses the tool's 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 structured into labeled sections (PURPOSE, USAGE, BEHAVIOR, RETURNS) making it highly scannable. Every sentence is informative with no redundancy. It is concise yet complete.

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

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

The description covers purpose, usage, destructive behavior, error conditions, return format, and notes encoding. Given the complexity (memory write, address range validation) it is fairly complete. A minor gap: it does not mention if the PSP emulator needs to be paused, but sibling tools ppsspp_pause/resume likely handle that. Overall, it provides sufficient context.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by noting that bytes are 'base64-encoded over the wire' and specifying the return format: 'Single line "Wrote N bytes → ADDR_HEX"'. This provides semantic information beyond the schema's 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 starts with a clear purpose statement: 'Write a contiguous byte sequence to PSP memory starting at the given address.' It specifies the verb (write), resource (PSP memory), and scope (contiguous byte sequence). It also lists specific use cases like 'installing cheat tables, patching code blocks, or seeding regions,' which distinguishes it from sibling tools that write single bytes/words or read memory.

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 provides explicit use cases: 'Use for installing cheat tables, patching code blocks, or seeding regions.' This gives context for when to use the tool. However, it does not explicitly contrast with alternatives like ppsspp_write8/16/32 for single-value writes or mention when not to use it. Still, the guidance is clear and helpful.

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