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

With no annotations provided, the description carries the full burden of disclosing side effects. The WARNING explicitly states this executes code in the debugged program, which is critical behavioral information. It could further clarify return value handling or thread context, but covers the essential safety concern.

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

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

Two sentences: one stating purpose, one providing a critical safety warning. Zero redundancy, front-loaded with the verb, and every word earns its place.

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

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

Given the high schema coverage and lack of output schema, the description is adequate. However, for a tool performing arbitrary code execution, it could mention prerequisites (process must be stopped) or return value behavior without violating conciseness.

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 clear examples ('printf("hello\n")'), so the structured schema fully documents the parameter. The description does not add semantic information beyond what the schema provides, which is appropriate given the high schema coverage.

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

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

The description clearly states the specific action ('Call a function') and the target ('in the target process'), distinguishing it from siblings like gdb_evaluate_expression (inspection) and gdb_execute_command (GDB CLI commands).

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

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

The WARNING about executing code provides strong implicit guidance about when to use this (intentional execution) versus inspection alternatives. However, it does not explicitly name gdb_evaluate_expression as the non-executing alternative.

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

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

With no annotations provided, the description carries the full burden. It discloses the halting conditions (breakpoint/completion) and the paused-state requirement, but omits whether this operation blocks until completion, error handling, or state side-effects.

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

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

Two sentences with zero waste: first defines the action, second states the critical precondition. Information is front-loaded and appropriately sized for the tool's simplicity.

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

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

Given zero parameters and no output schema, the description adequately covers the essential operational constraint (PAUSED prerequisite). For a simple control-flow tool among many siblings, this is sufficient, though noting blocking behavior would improve it.

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

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

The tool accepts zero parameters (empty schema), which per guidelines establishes a baseline of 4. The description appropriately requires no parameter clarification.

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

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

The description uses a specific verb ('Continue') with clear scope ('until next breakpoint or completion'), clearly distinguishing this from sibling stepping tools like gdb_step or gdb_next.

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 precondition 'Only use when program is PAUSED' which constrains when-not to use it. However, it doesn't explicitly name alternatives (e.g., 'use gdb_step to advance line-by-line instead').

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The term 'Delete' effectively signals destructive behavior (permanent removal), but the description omits error handling (e.g., behavior if breakpoint number doesn't exist), return values, or side effects.

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

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

The description is a single, efficient sentence with no wasted words. The action verb leads the sentence, making it immediately scannable and appropriately sized for a simple one-parameter operation.

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

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

Given the tool's simplicity (single required parameter), full schema coverage, and lack of output schema, the description is adequate. It could be enhanced by noting the permanent nature of deletion versus disabling, but it sufficiently covers the essential information needed for 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 has 100% description coverage ('Breakpoint number'), so the schema fully documents the parameter. The description adds minimal semantic value beyond the schema, merely reinforcing that deletion occurs 'by number' rather than by address or function name.

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 provides a clear verb ('Delete'), resource ('breakpoint'), and identifier method ('by number'). However, it does not explicitly differentiate from sibling tools like 'gdb_disable_breakpoint' (which keeps the breakpoint inactive rather than removing it), preventing a top score.

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

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

The description implies usage through the action verb ('Delete'), suggesting when to remove breakpoints entirely. However, it lacks explicit guidance on choosing deletion over 'gdb_disable_breakpoint' or prerequisites like the breakpoint needing to exist.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the 'by number' identifier but fails to explain that this is a state-mutating operation, that disabled breakpoints remain in the list but won't trigger, or that the operation is reversible via gdb_enable_breakpoint.

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

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

The description is exactly 5 words, front-loaded with the action verb, and contains zero redundancy. Every word is essential to understanding the tool's scope.

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

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

For a single-parameter tool with 100% schema coverage, the description is minimally adequate. However, given the lack of annotations (no destructiveHint) and no output schema, it misses opportunities to clarify the temporary nature of the action and its relationship to sibling enable/delete operations.

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

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

Schema description coverage is 100% (the 'number' parameter is described as 'Breakpoint number'), so the baseline is 3. The description reinforces this with 'by number' but adds no additional semantic value regarding constraints, valid ranges, or the source of the breakpoint number.

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

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

The description uses a specific verb ('Disable') that clearly differentiates from siblings like gdb_delete_breakpoint, gdb_enable_breakpoint, and gdb_set_breakpoint. It identifies the resource ('breakpoint') and the specific identification mechanism ('by number'), leaving no ambiguity about the tool's function.

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

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

While the verb 'disable' implies temporary deactivation (contrasting with 'delete'), the description does not explicitly state when to choose this over gdb_delete_breakpoint or mention that gdb_list_breakpoints should be used first to obtain the number. Usage is implied but not guided.

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

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

With no annotations provided, the description carries the full burden. It identifies the operation as an 'enable' (state mutation), but lacks details on idempotency, error conditions (e.g., invalid breakpoint number), or what occurs if the breakpoint is already enabled.

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

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

The description is exactly five words with zero redundancy. It is perfectly front-loaded and every word serves a purpose. No structural improvements possible.

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 state-toggle tool with 100% schema coverage, the description is adequate. It would benefit from noting error cases or return values, but the essential operation is fully covered given the tool's simplicity.

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

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

Schema description coverage is 100%, with the parameter 'number' fully documented as 'Breakpoint number' in the schema. The description adds minimal semantic value beyond 'by number,' so it meets the baseline for high schema coverage contexts.

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 provides a specific verb (Enable), target resource (breakpoint), and identification method (by number). It clearly distinguishes from siblings like gdb_disable_breakpoint (inverse operation), gdb_set_breakpoint (creates new), and gdb_delete_breakpoint (removes).

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

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

The description implies usage through the phrase 'by number,' suggesting the breakpoint must already exist (typically obtained via gdb_list_breakpoints). However, it does not explicitly state when to use this versus gdb_set_breakpoint or mention that the breakpoint must be disabled first.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to mention whether evaluation can modify program state (side effects), what frame/thread context applies, error handling for invalid syntax, or the return format (especially critical given no output schema exists).

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?

While the single sentence is not verbose, it suffers from under-specification rather than efficient conciseness. It restates the tool name without adding value, leaving significant gaps in information density that a debugging tool description should provide.

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 debugging tool with no annotations and no output schema, the description is insufficient. It lacks essential operational context: whether the expression evaluation is read-only or can mutate state, what it returns, and how it handles errors. The 100% input schema coverage is the only redeeming factor preventing a lower score.

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

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

With 100% schema description coverage ('C/C++ expression to evaluate'), the schema fully documents the single parameter. The description adds no additional semantic information (e.g., examples of valid expressions, syntax constraints), warranting the baseline score for high-coverage schemas.

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

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

The description states a clear verb ('Evaluate') and resource ('C/C++ expression'), but offers minimal scope clarification (e.g., in which frame/thread context). It relies heavily on the tool name to convey meaning and does not differentiate from siblings like 'gdb_call_function' or 'gdb_execute_command' that might overlap in functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'gdb_execute_command' (for raw GDB CLI) or 'gdb_call_function'. It omits critical context such as prerequisites (e.g., program must be stopped) or warnings about side effects in expressions.

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, description carries full burden and successfully discloses critical behavioral traits: auto-connection to Switch on first use, automatic handling of attach/monitor commands, and pre-set $main variable. However, lacks general warning about mutation risks inherent in arbitrary GDB command execution and does not describe output 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?

Perfectly front-loaded: purpose (sentence 1), sibling differentiation (sentence 2), critical constraints (sentences 3-4), environment context (sentence 5). Every sentence earns its place with zero redundancy despite covering multiple critical constraints and context signals.

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?

Strong compensation for missing annotations and output schema by documenting environmental state ($main variable), connection behavior, and prohibited commands. However, lacks description of return values or console output format, which would be valuable given no output schema exists and GDB commands produce variable 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?

Schema has 100% coverage establishing baseline 3. Description adds valuable context beyond schema by specifying commands can be 'CLI or MI' (Machine Interface) formats, hinting at syntax options not explicitly detailed in the schema's 'GDB command to execute' definition.

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

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

Description explicitly states 'Execute a raw GDB command (CLI or MI)' with specific verb and resource. Critically distinguishes from 15+ sibling tools by stating 'For Switch-specific operations, prefer the dedicated switch_* tools', clearly delineating when to use this generic tool vs. specialized 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?

Provides explicit prohibitions ('Do NOT use target remote', 'Do NOT use attach') and explains why ('session auto-connects', 'handled automatically'). Explicitly directs users to switch_* alternatives for Switch-specific operations, creating clear decision boundaries between this tool and its siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to specify whether this is read-only, what format the backtrace returns in (string vs structured data), or whether it affects debugger state. The phrase 'standard GDB backtrace' implies text output but lacks explicit confirmation.

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

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

The description is a single, front-loaded sentence with no redundant words. However, given the lack of annotations and output schema, extreme brevity becomes a liability rather than a virtue, as critical behavioral context is omitted.

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

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

Without an output schema or annotations, the description should specify the return format (e.g., 'returns a formatted string representation of the call stack'). It also omits thread safety notes and whether the operation is non-destructive, leaving significant gaps for a debugging tool.

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

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

The input schema has 100% description coverage (thread_id and max_frames are both clearly documented), so the description doesn't need to add parameter details. It neither supplements nor contradicts the schema, meeting the baseline expectation for high-coverage schemas.

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 a 'stack backtrace' and specifies it's the 'standard GDB backtrace,' which helps distinguish it from sibling tools like switch_my_bt. However, it doesn't differentiate from gdb_get_frame_info, which retrieves specific frame details rather than the full stack trace.

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

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

The description provides no guidance on when to use this tool versus alternatives such as gdb_get_frame_info (for single frame details) or the switch_* backtrace variants. No prerequisites, exclusions, or contextual triggers are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to state that this is a read-only operation, does not modify debugger state, or what specific data structure is returned. It omits critical context like whether the tool returns frame level, function name, arguments, or memory addresses.

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 consists of a single, efficient sentence with no redundant words. However, given the lack of output schema and annotations, the extreme brevity leaves significant gaps in agent understanding that slightly more elaboration could address.

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

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

While adequate for a zero-parameter tool, the description is incomplete given the absence of an output schema and the presence of numerous sibling inspection tools (gdb_get_registers, gdb_get_backtrace). Without hints about what frame information includes, agents cannot easily determine if this tool meets their specific debugging needs.

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 contains zero parameters, establishing a baseline score of 4. The description correctly implies the tool operates on the implicit 'current' frame without requiring explicit parameterization, though it could clarify that the current thread/frame context determines the target.

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

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

The description states a clear verb ('Get') and resource ('current stack frame'), identifying the tool's basic function. However, it uses vague language ('information') rather than specifying what frame details are returned (function name, file, line, arguments), and it fails to distinguish from sibling tool gdb_get_backtrace.

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

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

The description provides no guidance on when to use this tool versus alternatives like gdb_get_backtrace (which gets all frames) or gdb_select_frame (which changes frames). It omits prerequisites such as requiring the target program to be stopped in the debugger.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to indicate that this is a read-only operation, does not describe the return format (object, array, or string), and omits that results are for the currently selected thread/frame.

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 brief and front-loaded. While efficient, it is arguably too terse given the absence of annotations and output schema, leaving critical behavioral context undocumented.

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

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

For a zero-parameter inspection tool, the description adequately identifies the core function but lacks necessary contextual details such as output structure, thread/frame scoping, and execution prerequisites (stopped state) that an AI agent needs to use the tool effectively.

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

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

The tool accepts zero parameters, which establishes a baseline score of 4. No additional parameter context is required or provided.

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 provides a clear verb ('Get') and specific resource ('CPU register values'), distinguishing it from siblings like gdb_get_backtrace or gdb_get_variables. However, it does not explicitly differentiate from switch_get_pc or specify which register set is returned (general purpose vs. all).

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

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

No guidance is provided on when to use this tool versus alternatives like gdb_evaluate_expression (to read specific registers) or switch_get_pc. There are no prerequisites stated, such as requiring the target to be stopped.

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. While 'Get' implies a read operation, the description fails to disclose what status values are returned, whether the call is idempotent, performance characteristics, or side effects. It states the action but not 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 a single, efficient sentence with no redundant words. It is appropriately front-loaded with the verb. However, extreme brevity limits completeness given the lack of output schema.

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

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

With no output schema provided, the description should explain what status information is returned (e.g., execution state, stop reason). It fails to compensate for the missing structured return value documentation, leaving the agent unaware of what data to expect.

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

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

The tool has zero parameters (empty schema), which establishes a baseline score of 4 according to the evaluation rules. No parameter documentation is 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 uses a specific verb ('Get') and resource ('current status of the GDB session'), clearly distinguishing it from siblings like gdb_get_threads or gdb_get_registers which retrieve specific data rather than session state. However, it doesn't specify what 'status' means (e.g., running/stopped/connected).

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

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

No guidance is provided on when to use this tool versus alternatives, or under what conditions it should be called (e.g., before/after execution commands). Given the numerous sibling tools for execution control (gdb_continue, gdb_step), explicit usage context is absent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to specify what thread information is returned (IDs, names, states), whether the operation is read-only/safe, or if the target must be paused. It does not describe the output format despite lacking an output schema.

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

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

The description is extremely brief at six words with zero redundancy. It is front-loaded and efficient, though minimalism comes at the cost of completeness for a tool with rich sibling context.

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 debugging tool with no output schema, the description is minimally viable but incomplete. It omits what thread attributes are returned (e.g., thread IDs, current thread marker, stack pointers) and lacks context about GDB session requirements that would aid an agent in 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?

The tool has zero parameters, establishing a baseline score of 4. With no inputs to document and 100% schema coverage (vacuously), the description appropriately requires no additional parameter clarification.

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

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

The description uses a clear verb ('Get') and resource ('threads'), specifying the scope covers 'all' threads. However, it lacks explicit differentiation from siblings like gdb_select_thread (which manipulates thread selection state) or gdb_get_status (which may include thread 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 no guidance on when to use this tool versus alternatives like gdb_select_thread or gdb_get_backtrace. It does not mention prerequisites such as requiring an active debugging session or stopped inferior.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, the description does not confirm safety, disclose the return format (variable names, values, types), or mention error conditions (e.g., invalid frame numbers).

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 single sentence is efficient and front-loaded with the verb 'Get'. However, given the absence of annotations and output schema, the description is overly terse and misses essential behavioral context that would warrant a longer description.

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

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

Given the lack of output schema and annotations, the description fails to compensate by describing return values, data structure, or GDB state requirements. For a debugging tool with complex state dependencies, this leaves critical gaps in the contract.

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%, establishing a baseline of 3. The description itself adds no parameter information beyond what the schema already provides (thread_id defaults to current, frame defaults to 0), but the schema is sufficiently self-documenting.

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

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

The description clearly identifies the action ('Get') and resource ('local variables') with scope ('stack frame'). It implicitly distinguishes from siblings like gdb_get_registers or gdb_get_backtrace by specifying 'local variables', though it does not explicitly contrast with gdb_evaluate_expression.

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

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

The description provides no guidance on when to use this tool versus alternatives like gdb_evaluate_expression or prerequisites such as the program being paused. It lacks 'when-not-to-use' or prerequisite information.

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 disclosure burden. It indicates the program will pause, but omits key behavioral details: whether the interruption preserves program state for later continuation, where exactly execution stops (current PC vs breakpoint), and what the tool returns (status, frame info, or void).

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

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

Extremely efficient at three words plus parenthetical clarification. Every element serves a purpose: 'Interrupt' names the action, '(pause)' clarifies the effect, and 'a running program' identifies the target. No redundancy or wasted 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 zero-parameter debugging primitive, the description is minimally adequate, but gaps remain given the lack of annotations and output schema. It should ideally clarify that the program enters a stopped state awaiting further commands, and whether this maps to sending SIGINT or a soft pause.

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 contains zero parameters, establishing a baseline score of 4. The description appropriately requires no parameter elaboration since the interrupt action is typically unconditional in GDB contexts.

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 uses specific verbs ('Interrupt (pause)') and identifies the target resource ('a running program'). It clearly distinguishes from sibling tools like gdb_continue (resume), gdb_step (single step), and gdb_get_status (inspection) by emphasizing the pause action on active execution.

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

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

The description provides implied usage context (pause vs. continue), but lacks explicit guidance on when to use this versus gdb_step or gdb_next, and doesn't mention prerequisites like 'only works when a program is currently running' or the resulting stopped state.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'structured data' indicating the output format, but fails to clarify what fields are returned, whether the operation is read-only, or if the debugger must be in a specific state.

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

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

The single-sentence description is appropriately sized and front-loaded with the action verb. Every word serves a purpose, though the brevity leaves room for additional context given the lack of annotations or output schema.

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 listing tool with no parameters, the description provides the minimum viable information. However, given the absence of an output schema and annotations, it could be improved by specifying what breakpoint attributes (number, address, hit count, enabled status) are included in the 'structured data'.

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

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

The tool has zero parameters with 100% schema description coverage (empty schema). The description correctly makes no parameter claims, meeting the baseline expectation for parameter-less 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 action ('List') and resource ('breakpoints'), distinguishing it from sibling CRUD tools like gdb_set_breakpoint and gdb_delete_breakpoint. The addition of 'structured data' hints at the return format, though specificity is limited without an output schema.

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

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

No explicit guidance provided on when to use this tool versus alternatives (e.g., when to list all breakpoints vs. checking specific ones via gdb_get_status). The description lacks prerequisites or situational context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to specify whether the operation blocks until execution stops, what happens if the next line is never reached (infinite loop), or that this mutates execution state (advances PC). 'Step over' implies function calls are skipped but doesn't clarify error conditions.

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 single sentence is efficient and front-loaded, but given the rich sibling context (20+ related tools) and lack of annotations, it is undersized rather than appropriately concise. Additional sentences explaining the step-over vs step-into distinction would earn their place.

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

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

Incomplete given the high complexity of the GDB tool family. Lacks distinction from 'gdb_step', lacks behavioral details expected for debugger control commands (blocking/async nature), and provides no return value documentation (though no output schema exists, the behavioral contract is undocumented).

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 (empty object), so baseline 4 applies per evaluation rules. The description appropriately makes no mention of parameters since none exist.

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

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

The description uses the specific technical phrase 'Step over' which correctly identifies the debugger operation (advancing to next source line without entering functions). However, it does not explicitly distinguish this from the sibling 'gdb_step' tool, which performs 'step into' operations—a critical distinction for debugging workflows.

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

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

No guidance provided on when to choose this over 'gdb_step' (step into), 'gdb_continue' (run freely), or 'gdb_interrupt'. No prerequisites mentioned (e.g., requires active inferior process, valid source line info). The description states what it does but not when to use it.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. While 'Select' implies state mutation, the description fails to explain that this changes the current evaluation context for variable inspection and that the selection persists until changed or execution resumes.

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 single sentence is efficient and front-loaded with no redundant words. However, the extreme brevity leaves significant behavioral and contextual information unstated, making it slightly too concise for the complexity of GDB debugging operations.

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 complex debugging domain with numerous sibling tools and no output schema or annotations, the description is insufficiently complete. It should explain that frame selection scopes subsequent variable queries and expression evaluations, and clarify the relationship to backtrace navigation.

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?

With 100% schema description coverage for the single frame_number parameter, the schema already documents the 0-indexing convention and meaning. The description adds no supplemental parameter guidance, meeting the baseline expectation for high-coverage schemas.

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 provides a clear verb ('Select') and resource ('stack frame'), making the basic function unambiguous. However, it lacks differentiation from sibling inspection tools like gdb_get_frame_info, which also interact with frames but without changing debugger context.

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

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

The description offers no guidance on when to use this tool versus alternatives like gdb_get_frame_info or gdb_get_backtrace. It omits crucial context that frame selection affects subsequent variable inspection and expression evaluation contexts.

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 disclosure. Fails to explain that this changes debugger state (current thread context), whether the change persists across continues, or error conditions (invalid thread ID). 'Select' implies mutation but lacks safety/scope details.

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

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

Extremely terse (four words), but brevity here results in under-specification rather than efficient communication. While no sentences are wasted, the single sentence fails to earn its place by lacking actionable context for an AI agent.

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?

Inadequate for a state-changing debugging operation. Lacks explanation of side effects (subsequent commands target this thread), interaction with gdb_select_frame, and return behavior. Given zero annotations and no output schema, the description should compensate with richer behavioral 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?

Input schema has 100% description coverage ('Thread ID to select'). The description adds no additional semantics about the thread ID format (GDB's internal numbering vs system TIDs) or how to obtain valid IDs, meeting the baseline for high schema coverage.

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

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

States the basic action (select) and target (thread) but remains vague about what selection means in a GDB context. Does not distinguish from sibling tool gdb_get_threads, which likely lists threads rather than setting the active thread context.

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

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

Provides no guidance on when to use this tool versus alternatives, nor prerequisites (e.g., whether the program must be stopped). Missing context about how thread selection affects subsequent operations like gdb_get_backtrace or gdb_evaluate_expression.

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 clarifies location syntax but omits disclosure of state mutation (breakpoint persistence), error conditions, or side effects beyond the basic 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?

Two sentences with zero waste: first establishes core functionality, second provides sibling differentiation. Information is front-loaded and every sentence earns its place.

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

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

Adequate for tool selection given 100% schema coverage and sibling clarification, but lacks disclosure of state-modifying nature and error handling expected for a debugging command with no output schema or annotations.

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%, establishing baseline 3. Description reinforces location formats and adds domain context about offset-from-main exclusions, but does not elaborate on condition syntax or temporary breakpoint behavior 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 the specific action (Set a breakpoint) and supported location formats (function, file:line, or *address), distinguishing it from generic execution or inspection tools in the sibling set.

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

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

Explicitly names sibling tool 'switch_break_at' as the alternative for offset-from-main breakpoints, providing clear guidance on when to use the alternative instead. Lacks broader contextual guidance versus gdb_execute_command.

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

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

With no annotations provided, the description carries the full burden. While 'step into' describes the execution flow, it omits that this operation blocks until completion, mutates program state (registers/memory), and requires an active inferior process.

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

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

Extremely concise at 5 words. Single sentence immediately conveys the operation without filler. Perfectly front-loaded for quick comprehension.

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

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

Adequate for a zero-parameter tool with no output schema, but given the density of sibling debugging tools (28 total), the description should clarify blocking behavior and error conditions (e.g., requires active target) to aid tool selection.

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

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

Zero parameters present. Per guidelines, 0 params = baseline 4. The schema requires no additional semantic explanation.

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

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

Uses specific debugging terminology 'step into' plus resource 'instruction', clearly indicating this executes the next machine instruction and enters function calls. However, it does not explicitly contrast with sibling gdb_next to help users select the correct stepping behavior.

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 no guidance on when to use this versus gdb_next (step over), gdb_continue (resume execution), or gdb_call_function. No prerequisites or conditions are mentioned.

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

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

With no annotations provided, the description must carry the full behavioral burden. It successfully explains the relative addressing calculation, but omits side effects (e.g., overwriting existing breakpoints at the same location), error handling, or session persistence details that would help an agent predict 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?

Two sentences with zero waste: first states the operation and addressing model, second provides a concrete example. The information is front-loaded and the example directly supports the parameter semantics.

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

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

For a single-parameter mutation tool without output schema, the description adequately covers the primary function and parameter interpretation. Minor gap in not describing failure modes or return behavior, but acceptable given the tool's constrained scope.

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?

While the schema has 100% coverage describing the offset format, the description adds crucial semantic context that the offset is calculated 'relative to the base of main ($main)' rather than being an absolute address or file offset, clarifying the addressing model beyond the schema's 'into main executable'.

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

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

The description uses a specific verb ('Set') with clear resource ('breakpoint') and scope ('relative to the base of main'). It effectively distinguishes itself from the sibling 'gdb_set_breakpoint' by specifying the offset-relative-to-main addressing mode, which is a critical semantic difference.

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 a concrete example ('0x3a5f10') that clarifies input format and the arithmetic ($main+offset). However, it lacks explicit guidance on when to choose this over 'gdb_set_breakpoint' or error conditions (e.g., invalid offsets).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It successfully clarifies the return value calculation (offset relative to main vs. absolute address), but fails to mention safety characteristics (read-only vs. destructive), error conditions, or return value formatting.

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

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

The description is a single, information-dense sentence with no filler content. The key information (action, target, and calculation method) 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?

While the description explains what is returned conceptually, it lacks an output schema and does not specify the return format (e.g., hexadecimal string, integer, JSON object). For a debugging utility where format is critical, this omission leaves a significant gap.

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

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

The tool has zero parameters, which per the evaluation rules establishes a baseline score of 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 explicitly states the tool retrieves the current Program Counter (PC) and specifies the critical detail that it returns an offset relative to the base of main, distinguishing it from siblings like gdb_get_registers (which returns all registers) and switch_my_bt (which returns backtraces).

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

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

The description provides no guidance on when to use this tool versus alternatives such as gdb_get_registers or switch_my_bt, nor does it mention prerequisites like needing an active debugging session or a stopped process.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It successfully explains the conversion logic (absolute to relative offset), but fails to specify whether this is a read-only calculation or modifies debugger state, what format the return value takes, or how errors are handled for invalid addresses.

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

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

The description is a single, information-dense sentence that front-loads the core functionality. Every clause earns its place: the transformation verb, the relative target, and the concrete examples. No redundant or filler text is present.

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 single-parameter simplicity and lack of output schema, the description adequately explains the input expectations. However, it omits the return value format (string offset? integer?) and does not explain what 'base of main' refers to (e.g., the main function entry point), which would be valuable contextual information for an agent.

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

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

The input schema has 100% description coverage, establishing a baseline of 3. The description reinforces the parameter semantics by repeating the example formats found in the schema ('$x0', '0x8012345'), but does not add significant new semantic information such as supported register name formats or address validation rules beyond the schema.

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

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

The description clearly states the core operation using specific verbs ('Convert') and identifies the resource ('absolute address or register value') and target ('offset relative to the base of main'). However, it does not explicitly differentiate from sibling tools like 'gdb_evaluate_expression' that might also handle address calculations.

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?

While the description provides input format examples ('$x0' or '0x8012345'), it offers no guidance on when to use this tool versus alternatives such as 'switch_get_pc' or 'gdb_evaluate_expression'. There are no stated prerequisites, exclusions, or workflow context.

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

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

No annotations provided, so description carries full burden. Discloses important behavioral limitation (misses first address) and implementation method (walking frame pointer chain). Implies read-only operation via 'Print', though could explicitly state no side effects.

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

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

Two sentences, zero waste. First sentence defines function and mechanism; second provides critical limitation and workaround. Perfectly 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?

Without output schema, the description adequately explains the output format ('absolute addresses') and a key limitation. Given the tool's narrow scope (0 parameters, simple output), this is sufficient, though mentioning read-only safety would strengthen it further.

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. Baseline score of 4 applies as there are no parameters requiring semantic clarification.

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

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

Clearly states the tool prints backtraces as absolute addresses using frame pointer chain walking. Specific about method and output format. However, it does not explicitly differentiate from sibling 'switch_my_bt2', which appears to be a variant.

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 guidance about a key limitation ('Often misses the first address') and explicitly recommends an alternative command ('p/x $lr') for that case. Lacks explicit comparison to sibling tools like 'switch_my_bt2' for when to use which variant.

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

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

With no annotations provided, the description carries the full burden. It discloses the calculation method (walks frame pointer chain) and output format (module-relative offsets), establishing it as a read-only operation via the verb 'Print'. However, it omits error conditions, failure modes (e.g., missing frame pointers), and exact output structure.

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

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

Two well-structured sentences with zero waste. The first sentence front-loads the primary purpose, while the second provides essential technical implementation details. Every word earns its place.

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

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

For a zero-parameter debugging utility without output schema, the description adequately covers the core functionality and distinguishing characteristics. It could be improved by explicitly contrasting with 'switch_my_bt' or describing the output format, but it provides sufficient context for 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 tool has zero parameters and 100% schema coverage. Per the evaluation rules, zero-parameter tools receive a baseline score of 4. The description appropriately focuses on behavior rather than non-existent parameters.

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

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

The description uses specific technical verbs ('Print', 'Walks', 'resolves') and clearly identifies the resource (backtrace). It distinguishes from sibling tools like 'switch_my_bt' and 'gdb_get_backtrace' by specifying the unique characteristic: offsets relative to the base of main rather than absolute addresses.

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 explains the specific output format (module-relative offsets) which implies when to use it (when needing position-independent offsets), but lacks explicit when-to-use guidance or named alternatives. It does not state when to prefer this over 'switch_my_bt' or 'gdb_get_backtrace'.

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

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

With no annotations provided, the description carries the full burden and effectively discloses the write operation ('Writes'), the exact bytes being written (0xD503201F), and the architecture (ARM64). However, it omits mention of side effects like cache flushing, permission requirements, or reversibility.

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

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

Two sentences with zero waste: the first states the high-level operation, the second provides the specific behavioral implementation detail (ARM64 hex value). Perfectly front-loaded and appropriately sized for the tool's 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?

For a single-parameter mutation tool without output schema, the description adequately covers the operation specifics. It could be improved by explicitly noting this is a destructive memory write (since no annotations indicate this), but the verb 'Writes' provides sufficient disclosure for the domain.

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?

Although the schema has 100% coverage describing the offset format, the description adds crucial semantic context that the offset is relative to 'main' ('from main', '$main+offset'), clarifying the base address calculation not explicit in the parameter schema alone.

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

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

The description uses a specific verb ('NOP') and identifies the exact resource being modified (instruction at offset from main). It distinguishes from siblings like switch_replace (arbitrary replacement) and switch_break_at by specifying the ARM64 NOP operation.

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

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

While the specificity of 'NOP' implies usage (disabling instructions), there is no explicit guidance on when to choose this over switch_replace or switch_stub, nor are prerequisites like an active debugging session mentioned despite the presence of switch_start_session in siblings.

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

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

With no annotations provided, the description carries the full burden. It adequately explains the 16-byte read scope and output format ('replace' commands), but omits critical operational details: whether this requires an active debugging session, the exact output format/destination, and whether it has any side effects on target 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?

Single dense sentence efficiently communicates action, parameter context, data volume (4 instructions/16 bytes), output format, and purpose. No redundant words; every clause provides necessary technical context for a low-level debugging 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?

Appropriate for a single-parameter tool, but gaps remain given the absence of annotations and output schema. Missing: session state requirements (likely requires switch_start_session), whether output goes to console or a buffer, and error conditions (invalid offset, unreadable memory).

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%, establishing a baseline of 3. The description references the offset parameter contextually ('at an offset') and clarifies the operation reads 16 bytes from that location, adding domain-specific meaning about the hooking window size that complements the schema's format 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?

Specific verb ('dump'), resource ('original instructions'), and scope ('4 instructions / 16 bytes') clearly distinguish this from sibling tools like switch_replace (which applies replacements) and switch_stub (which inserts code). The purpose—saving state for later restoration—is unambiguous.

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

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

Implies the temporal context ('after hooking') suggesting it should be used before modifying code, but lacks explicit sequencing guidance like 'Use before switch_replace' or prerequisite notes regarding active sessions (implied by sibling switch_start_session but not stated).

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

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

No annotations provided, so description carries full burden. It discloses the internal operations performed (calls to get_pc, localize with $lr argument, and my_bt2) and precisely describes return values (PC offset, calling offset, full backtrace relative to main). Missing only error conditions or side effects.

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

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

Two efficient sentences: first establishes the composite nature and constituent operations, second specifies return values. No redundancy or filler. Front-loaded with the 'Combined trace' concept.

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 exists, so description appropriately explains return values (offsets and backtrace). Given zero parameters and no annotations, the description successfully explains both the composed behavior and output format. Minor gap regarding error handling or GDB session requirements.

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

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

Input schema has zero parameters, establishing baseline of 4. No parameter documentation 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?

States exactly what the tool does: a combined trace that runs get_pc, localize $lr, and my_bt2 in one command. Explicitly distinguishes from sibling tools (switch_get_pc, switch_localize, switch_my_bt2) by positioning itself as a convenience wrapper that bundles them.

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

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

Implies usage context by describing it as a 'Combined trace' that runs multiple operations 'in one command,' suggesting when to use it (when you need all three results together). Lacks explicit 'when not to use' guidance or comparison to calling the individual tools separately.

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 fails to disclose critical behavioral traits of this mutation operation: whether changes are persistent across sessions, if they affect running execution immediately, memory protection requirements, or reversibility. Only mentions the hex format which is already in schema.

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

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

Two sentences with no wasted words. The structure front-loads the core action. However, extreme brevity is inappropriate given the lack of annotations and the dangerous nature of runtime code modification.

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 destructive low-level debugging tool with no annotations and no output schema, the description is insufficient. It omits session requirements (implied by switch_start_session sibling), safety warnings, or execution effects that are essential for correct and safe 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 has 100% description coverage with clear type/format info. The description adds minimal value beyond the schema—merely confirming both parameters are hex values and implying the offset is relative to main, which the schema already specifies as 'main executable'.

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 specific action (replace), target resource (instruction), and location context (offset from main). It effectively distinguishes this from siblings like switch_no_op or switch_stub by emphasizing the arbitrary 'new instruction' replacement capability.

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

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

The description provides no guidance on when to use this tool versus similar sibling tools (switch_no_op, switch_stub) or prerequisites like requiring an active session. No mention of when replacement is preferable to other modification methods.

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

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

With no annotations provided, the description carries full disclosure burden. It successfully documents the configuration mechanism (SWITCH_IP/PORT env vars with defaults), specific automated actions (loading Switch debug commands, attaching, setting $main to cross2_Release.nss base), and the specific executable used (gdb-multiarch). Minor gap: does not specify error behavior on connection failure or idempotency of repeated calls.

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 sentences, zero redundancy. Front-loaded with the core action, followed by mandatory prerequisite warning, configuration details, automated behaviors, and prohibitions. Each sentence conveys distinct operational information (what, when, how, what-not).

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

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

Given the lack of annotations and output schema, the description adequately covers the initialization lifecycle, environment configuration, and specific technical automation (cross2_Release.nss base address). Minor deduction for not describing return values, error states, or session termination conditions given this is a stateful connection establishment 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 zero parameters, warranting a baseline of 4. The description adds value by documenting implicit configuration inputs (environment variables SWITCH_IP and SWITCH_PORT) and their default values (192.168.1.235:22225), effectively serving as parameter documentation outside 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 opens with specific verbs ('Start gdb-multiarch and connect') and clearly identifies the target resource (Switch/Yuzu GDB stub). It effectively distinguishes itself from the 20+ sibling tools by establishing its role as the mandatory initialization step.

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 temporal ordering ('MUST be called before any other tool') and explicitly prohibits manual alternatives ('Do NOT manually run target remote, attach, or set $main'). This creates clear boundaries between this tool and both its siblings and manual GDB workflows.

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

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

With no annotations provided, the description carries the full burden. It specifies the primary effect (stopping and disconnecting) but omits behavioral details like whether this terminates the target process, cleans up breakpoints, requires an active session, or is reversible.

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 single sentence is perfectly efficient with zero waste. It front-loads the action ('Stop') and immediately qualifies the scope ('gdb-multiarch session') and secondary target ('Yuzu'), delivering exactly the information needed for tool selection.

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

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

For a zero-parameter lifecycle tool, the description is adequate, mentioning both the debugger (gdb-multiarch) and the target platform (Yuzu). However, it lacks details about the terminal state of the debugging target (detached vs. terminated) that would be necessary for complete operational confidence.

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

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

The input schema has zero parameters, which establishes a baseline score of 4. The description correctly implies no configuration is needed for this operation, though it does not explicitly state 'no arguments 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 uses specific verbs ('Stop', 'disconnect') and identifies the exact resources affected ('gdb-multiarch session', 'Yuzu'). It clearly distinguishes this tool from its obvious sibling 'switch_start_session' and operational tools like 'gdb_interrupt' by specifying session termination and disconnection.

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?

While the description implies this is a cleanup/termination tool, it provides no explicit guidance on when to invoke it versus pausing execution or when to avoid using it (e.g., during critical operations). The inverse relationship with 'switch_start_session' is clear but not stated.

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

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

No annotations are provided, so description carries full burden. It excellently discloses the specific bytes written (0xD65F03C0), architecture (ARM64), and immediate effect (function returns immediately). Minor gap: doesn't mention whether the patch persists, is reversible, or what return value the stubbed function yields.

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

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

Two sentences with zero waste: first states the action and target, second explains the mechanism and immediate behavioral consequence. Information is front-loaded and every clause earns its place.

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

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

Given this is a binary patching tool with no output schema, the description adequately covers the immediate side effects. However, for a destructive write operation, it could mention whether the change is persistent across sessions or reversible (e.g., can the original bytes be restored?).

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 clear parameter description, establishing baseline 3. Description adds crucial semantic context that the offset is 'from main' (base address), reinforcing the calculation '$main+offset' which is essential for correct invocation in a debugging context.

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 provides specific verb ('Stub') + resource ('function at the given offset from main') and distinguishes from siblings by specifying it writes 'ARM64 RET (0xD65F03C0)'—clearly differentiating from switch_no_op or switch_replace which would write different instructions.

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

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

The description implies usage through mechanism explanation ('making the function return immediately'), but provides no explicit guidance on when to choose this over siblings like switch_no_op or switch_replace, nor any prerequisites or warnings about 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?

No annotations provided, so description carries full burden. It indicates read-only behavior via 'Print' and specifies output format 'xxd-style', but omits safety details (what happens on invalid addresses), size limits, or whether this pauses target execution. Minimum viable disclosure for a debugging inspection 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?

Single sentence, front-loaded with action verb 'Print', zero redundancy. Every word earns its place: 'xxd-style' specifies format, 'memory' distinguishes from registers/variables, 'given address' links to required parameter.

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

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

Adequate for a simple 2-parameter inspection tool with no output schema. Describes what the tool does and its format. Could be improved by noting address format (hex string expected) or confirming read-only nature, but sufficient for agent selection among debugging 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?

Schema coverage is 100% with both 'address' and 'size' well-documented in the schema. Description mentions 'at the given address' which links to the parameter, but adds no semantic details beyond schema (e.g., address format expectations, hex vs decimal). Baseline 3 appropriate for high schema coverage.

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

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

The description uses specific verb 'Print' with clear resource 'hex dump (xxd-style) of memory', distinguishing it from siblings like gdb_get_registers (registers) or switch_print_trace (execution trace). The 'xxd-style' qualifier and 'memory' scope make the purpose unambiguous.

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

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

No explicit when-to-use or alternative recommendations provided. However, the specificity of 'hex dump' and 'xxd-style' implies usage context (raw memory inspection vs. structured variables). Lacks guidance on when to prefer this over gdb_evaluate_expression for memory viewing.

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