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

With no annotations provided, the description fully discloses that this is a privileged operation executing code in the debugged process, with side effects and state modification. It lists examples of callable functions and warns of full privileges.

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

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

The description is concise and well-structured: it starts with the purpose, includes a warning, provides examples, and states prerequisite. Every sentence adds value without redundancy.

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

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

Despite no output schema, the description covers purpose, prerequisites, examples, and warnings, making it complete for a privileged function-call tool. The return value is not critical as the tool's action is the main point.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context by explaining the source of session_id and giving examples of function_call expressions, enhancing understanding 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 it calls a function in the target process, with specific examples and warning about it being a privileged operation. It distinguishes from siblings like gdb_evaluate_expression by focusing on function calls and side effects.

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 when to use (to call functions in the debugged process) and prerequisites (session_id from gdb_start_session). It does not explicitly contrast with siblings like gdb_evaluate_expression or gdb_execute_command, but the specialization is clear enough.

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, description carries behavioral burden. It discloses that it continues until next breakpoint or completion, and that it fails if program not paused. Does not mention side effects like program termination, but covers key preconditions and failure modes.

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?

Concise and well-structured. Purpose is front-loaded, followed by important usage conditions in a clear hierarchy. Every sentence adds value, no wasted words.

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

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

Given the tool's simplicity (2 params, no output schema, no nested objects), the description fully covers preconditions, failure modes, and alternatives. Complete for an agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. Description adds minimal value beyond schema: session_id source is already in schema, timeout description matches schema. No new meaning added.

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

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

The description clearly states the verb 'Continue execution' and the resource 'program'. It distinguishes itself from siblings by specifying preconditions (program must be paused) and provides alternative tools for different states.

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

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

Explicitly states when to use (program paused), when not to use (if not started or already running), and provides exact alternatives: gdb_execute_command with 'run' for not started, gdb_interrupt to pause if running.

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

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

With no annotations, the description must disclose behavioral traits. It states the action is irreversible ('cannot be recovered') and mentions the requirement for a session_id. This provides sufficient transparency for a simple deletion tool.

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

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

The description is three sentences long, with the action first, followed by prerequisite and warning. Every sentence adds value, and there is no redundancy.

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

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

Given the tool's simplicity (no output schema, two straightforward parameters), the description covers purpose, prerequisite (session_id), how to get the number, and the irreversible nature. It is complete for an agent to use correctly.

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

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

The input schema has 100% description coverage, but the description adds meaning by specifying that session_id comes from gdb_start_session and that number corresponds to breakpoint numbers from gdb_list_breakpoints. This adds context 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 'Delete a breakpoint by its number.' This is a specific verb ('delete') and resource ('breakpoint'), and it distinguishes the tool from siblings like gdb_disable_breakpoint (disable vs delete) and gdb_list_breakpoints (list vs delete).

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 advises using gdb_list_breakpoints to see breakpoint numbers, indicating a prerequisite step. It also warns that the breakpoint cannot be recovered after deletion. It does not explicitly state when to avoid using this tool, but the context is adequate given the sibling set.

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

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

No annotations provided, but description fully discloses behavior: disabled breakpoints are not hit but remain in the list. No contradictions.

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

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

Two sentences, highly concise, no fluff. Action 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?

For a simple mutation tool, description covers action and side effects. However, no mention of return value or success indication; output schema missing but not critical. Could add brief note on expected outcome.

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?

Parameter descriptions already in schema cover both parameters (session_id and number). Description adds context: session_id comes from gdb_start_session and number is the breakpoint number, reinforcing schema but not adding new semantics.

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

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

Clearly states 'Disable a breakpoint by its number without deleting it', specifying the verb (disable), resource (breakpoint by number), and scope (without deletion). Distinct from sibling tools like gdb_delete_breakpoint and gdb_enable_breakpoint.

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

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

Explicitly mentions when to use: to disable without deleting, and when to use alternative (gdb_enable_breakpoint for re-enabling). Also notes session_id prerequisite from gdb_start_session.

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

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

No annotations, but description explains enabled breakpoints pause execution. Sufficient for a simple enable action; no contradictions.

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

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

Two clear sentences, no fluff, front-loaded with action and purpose.

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

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

Low complexity tool; description covers purpose, parameters, and prerequisite. No missing elements for effective use.

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

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

Schema coverage 100% with descriptions. Description adds minimal extra context beyond schema; baseline score justified.

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 enables a disabled breakpoint by number, with effect of pausing execution. Distinguishes from siblings like gdb_disable_breakpoint and gdb_delete_breakpoint.

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

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

Explicitly mentions required session_id from gdb_start_session. Does not list alternatives but context implies use after disable; brief but adequate.

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

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

No annotations exist, so the description must fully disclose behavior. It states the tool can call functions but does not mention potential side effects of such calls. It also fails to specify error handling or the format of the returned value, leaving important behaviors undisclosed.

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

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

The description is two sentences long, starts with the core purpose, and adds necessary context without redundancy. Every sentence is informative and efficient.

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 an output schema, the description should explain the return value format. It only says 'return its value', which is vague. For a tool that evaluates expressions, more detail on the result type (e.g., string representation) is needed. However, the tool is simple and the description covers the input well.

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 descriptions, but the description adds context by specifying that session_id comes from gdb_start_session and by listing capabilities (dereference, call functions) that go beyond the schema parameter descriptions.

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

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

The description clearly states the tool evaluates a C/C++ expression and returns its value, with specific examples like accessing variables and dereferencing pointers. This distinguishes it from siblings like gdb_call_function which is more specialized.

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 mentions the required session_id parameter from gdb_start_session, implying the tool is used only after starting a session. However, it does not explicitly address when not to use it or compare with alternatives like gdb_call_function, though the context is relatively clear.

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

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

Discloses that CLI commands are auto-handled and formatted, multiline commands supported with , MI commands return structured data. Mentions timeout. No annotations provided, so description carries burden. Could mention potential side effects but adequate.

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

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

Well-structured with front-loaded purpose, then details, then note about alternative. Slightly lengthy but each part adds value; could be more concise but effective.

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

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

Given 3 parameters, no output schema, and many sibling tools, description is complete: purpose, usage guidelines, parameter details, examples, and alternative tool reference. Agent can correctly select and invoke.

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 100%, description adds significant context: session_id source, command types, timeout default and purpose. Enhances understanding beyond schema with examples and CLI/MI differentiation.

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 verb 'Execute' and resource 'GDB command'. Distinguishes from sibling tool gdb_call_function by noting preference for function calls. Provides examples of CLI and MI 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?

Explicitly explains when to use this tool (executing GDB commands) and when to use gdb_call_function instead. Mentions requirement of session_id from gdb_start_session. Provides common examples.

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?

Missing annotations put the burden on the description, which only mentions requiring a session_id and the type of output. No disclosure of side effects (e.g., thread state requirements), error behavior, or idempotency. Minimal behavioral info is provided.

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

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

Three sentences with front-loaded main action. No fluff, each sentence adds necessary context. Efficiently communicates purpose, scope, and a prerequisite.

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, so the description should explain return format. It only vaguely says 'Shows...' without specifying if output is a list, string, or structured data. Given the complexity of a backtrace, this is incomplete for effective use.

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

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

Schema coverage is 100% with parameter descriptions, but the description adds value by clarifying that thread_id defaults to current thread (None) and explicitly stating session_id is required. This enhances understanding beyond the 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 clearly states 'Get the stack backtrace' with specific details on thread scope and output content (function calls, file locations, line numbers). This distinguishes it from siblings like gdb_get_frame_info (get specific frame) and gdb_get_registers (register values).

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

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

No guidance on when to use this tool versus alternatives like gdb_get_frame_info or gdb_get_threads. The description only implies use for backtrace retrieval but lacks explicit context for selection, such as prerequisites or when not to use.

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

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

No annotations are provided, so the description carries full behavioral burden. It states the tool returns details and requires a session_id, but does not disclose behavior on error (e.g., invalid session ID, no current frame), side effects, or rate limits. This leaves some behavioral ambiguity.

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

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

Two sentences, front-loaded with the action, no wasted words. Every sentence adds value: purpose, returns, prerequisite, and usage hint.

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

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

Given low complexity (1 param, no output schema), the description covers purpose, return fields, and usage context. It lacks explicit details on error cases or return format (e.g., data types), but is sufficient for an experienced user.

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% (session_id documented in schema). The description adds no new parameter information beyond restating the prerequisite. Per guidelines, baseline is 3 when coverage is high.

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 gets information about the current stack frame, listing specific return fields (function name, file location, line number, address). It distinguishes from siblings like gdb_get_backtrace (which gives entire stack) and gdb_select_frame (which changes the current frame).

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

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

The description explicitly advises to use gdb_select_frame first to change the current frame if needed, and requires session_id from gdb_start_session. However, it does not explicitly rule out alternatives like gdb_get_backtrace for frame details, though the singular 'current frame' implies a single frame.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states the action without indicating that it is a read-only operation with no side effects. This is a notable gap for a tool that retrieves data.

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

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

The description is extremely concise with two sentences, front-loading the purpose. Every word serves a function.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the essential purpose and prerequisite. However, it lacks any indication of the return format or the number of registers, which could be helpful.

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% coverage, and the description adds no additional meaning beyond what the schema already provides. The schema already states session_id is an integer and required. Baseline 3 is appropriate.

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

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

The description uses the specific verb 'Get' and resource 'CPU register values for the current frame', clearly defining what the tool does. It distinguishes itself from sibling tools like gdb_get_variables (variables) and gdb_get_backtrace (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 mentions that a session_id is required and that it comes from gdb_start_session, providing a prerequisite. However, it does not provide explicit guidance on when to use this tool versus alternatives, nor does it state when not to use it.

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

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

With no annotations, the description must fully disclose behavior. It only states the tool gets status but provides no details about side effects, blocking behavior, error handling, or what happens if the session is invalid. The lack of behavioral context leaves the agent uncertain about the operational semantics.

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

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

The description is extremely concise: two sentences conveying the core purpose and a critical prerequisite. Every word serves a purpose, and no extraneous information is present. It is front-loaded with the action and follows with a necessary dependency.

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

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

Given the tool's simplicity (one required parameter, no output schema), the description covers the essential input requirement. However, it omits what the return value represents (e.g., status details, session state). For a tool that outputs data, this is a gap, but the minimal context is acceptable.

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

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

The schema description coverage is 100% for the single parameter (session_id). The description echoes the schema's description, adding no new meaning. Since schema already explains the parameter, the description adds minimal value. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get the current status of the GDB session.' It uses a specific verb ('Get') and resource ('status of the GDB session'), distinguishing it from other GDB tools that manipulate breakpoints or execution. However, it does not elaborate on what 'status' entails, which could be improved.

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 mentions the prerequisite session_id and its source ('obtained from gdb_start_session'), providing some usage guidance. However, it does not offer explicit when-to-use or when-not-to-use instructions relative to sibling tools, nor does it clarify alternatives. This is adequate but not comprehensive.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only operation by saying 'Get information', but it does not explicitly state that it is non-destructive or require any permissions. More explicit safety cues would improve transparency.

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

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

The description is concise, consisting of two short sentences that convey the purpose and prerequisite without any unnecessary words.

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

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

The description adequately explains what the tool returns (thread IDs, states, current thread) and the required argument. Given the simple input and no output schema, the description is fairly complete. It could mention the read-only nature, but overall it provides enough 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?

The schema covers the single parameter with a description, and the tool description repeats that session_id comes from gdb_start_session. Since schema coverage is 100%, the baseline is 3, and the description adds no new semantic detail beyond what the schema provides.

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

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

The description clearly states that it gets information about all threads, listing specific data like thread IDs, states, and the current thread. It distinguishes itself from sibling tools like gdb_select_thread or gdb_get_status.

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 specifies that the session_id parameter must be obtained from gdb_start_session, providing a clear prerequisite. However, it does not give guidance on when to use this tool versus alternatives like gdb_get_status, so the context is present but not exhaustive.

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

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

No annotations are provided, so the description must disclose behavior. It implies a read-only operation ("get") but does not explicitly state that no state is modified, nor does it mention potential error conditions (e.g., invalid session). For a simple getter, this is adequate but not rich.

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

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

Two concise sentences with zero unnecessary words. The essential information is front-loaded: the action and the key prerequisite.

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

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

The description explains the tool's purpose and a prerequisite, but lacks details about the return format (e.g., list of variable names/values) or error scenarios. Given no output schema, the agent may need more context to interpret results.

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

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

Schema coverage is 100% with all parameters described. The description reinforces that session_id comes from gdb_start_session, but adds no new semantics for thread_id or frame beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb "Get" and resource "local variables" with context "for a specific stack frame in a thread", distinguishing it from sibling tools like gdb_get_backtrace (stack trace) and gdb_get_registers (registers). It is specific and unambiguous.

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

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

The description mentions a prerequisite (session_id from gdb_start_session) but provides no guidance on when to use this tool versus alternatives, nor any exclusions or recommended 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?

Description explains that the tool pauses execution, but does not explicitly state if it is non-destructive or what state it leaves the program. With no annotations, this is a moderate disclosure of behavior.

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

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

Three sentences cover purpose, usage scenarios, post-interrupt actions, and parameter source. Every sentence is valuable, no fluff.

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

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

Given the simple one-parameter tool and no output schema, the description covers usage context and post-interrupt actions adequately. Could mention potential side effects or state safely but overall sufficient.

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

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

Parameter schema provides 100% coverage with description 'Session ID from gdb_start_session'. The tool description adds value by linking to sibling tool output, exceeding baseline for full 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 'Interrupt (pause) a running program.' It uses a specific verb and resource, and it is distinct from sibling tools like gdb_continue and 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?

The description provides explicit when-to-use scenarios (running, no breakpoint, stuck) and what to do after interrupting (use other GDB commands). It also notes the prerequisite session_id from gdb_start_session.

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

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

No annotations are provided, so the description carries the full burden. It fully discloses the return format: an array of objects with fields like number, type, enabled status, address, etc. It notes it's structured data and easier to filter. It does not cover error cases, but for a read-only listing, this is adequate.

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

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

The description is three concise sentences: first states purpose, second lists return fields, third gives use cases and prerequisite. Every sentence adds value and is efficiently structured.

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

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

Given the tool's simplicity (list breakpoints, one parameter, no output schema), the description covers purpose, return values, usage scenarios, and how to obtain the required parameter. It is complete for the tool's complexity.

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

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

Schema coverage is 100% with one parameter (session_id) already described as 'Session ID from gdb_start_session'. The description repeats this, adding no new semantic information beyond what the schema provides. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's action ('List all breakpoints') and resource ('breakpoints as structured data'). It distinguishes itself from sibling tools like gdb_set_breakpoint and gdb_delete_breakpoint by focusing on listing. The verb 'list' and resource 'breakpoints' are specific and unambiguous.

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

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

The description provides explicit use cases: 'verify breakpoints were set correctly, check which have been hit, and inspect their exact locations.' It also advises preferring this over text output for easier filtering. While it doesn't explicitly state when not to use, the context is clear.

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

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

Without annotations, the description carries the burden. It discloses that the tool steps over functions and requires a paused state. However, it does not mention potential side effects, timeout behavior, or what happens if the program is not paused. The timeout_sec parameter is in the schema but not described behaviorally.

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

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

The description is three concise sentences with no wasted words. The crucial condition is highlighted in all caps. Front-loaded with the core action.

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

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

For a simple step-over tool with no output schema, the description sufficiently covers the purpose, prerequisite, and usage condition. It could mention that the tool resumes execution and then pauses again, but this is implicitly understood.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context that session_id comes from gdb_start_session, which is helpful but minimal beyond what the schema already says.

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 action: 'Step over to the next line (doesn't enter function calls).' This clearly distinguishes it from gdb_step (which steps into functions), providing a specific verb and resource.

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

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

The description provides clear usage context: 'Only works when program is PAUSED at a specific location' and 'Requires session_id parameter (obtained from gdb_start_session).' It implicitly contrasts with stepping into functions, but does not explicitly name the alternative sibling (gdb_step).

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 convey behavioral traits. It discloses that selecting a frame changes the context for commands like gdb_get_variables and gdb_evaluate_expression. However, it does not mention error handling (e.g., invalid frame number) or side effects like modifying GDB state beyond context change.

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

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

The description is concise with four sentences, each serving a clear purpose: stating the action, defining frame numbering, explaining the effect, and listing prerequisites. No redundant information, and key details are front-loaded.

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

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

Given no annotations and no output schema, the description covers the essential aspects: purpose, parameter semantics, usage context, and prerequisite. It could mention potential errors, but for a simple selection tool, the completeness is adequate.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the frame_number parameter in context (0=innermost) and specifying that session_id must come from gdb_start_session. This enhances understanding beyond the schema's brief descriptions.

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

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

The description clearly states the tool selects a specific stack frame to be the current frame, distinguishing it from sibling tools like gdb_get_frame_info and gdb_get_backtrace. It specifies the verb 'select' and the resource 'stack frame', with clear differentiation from listing or inspecting frames.

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

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

The description provides usage guidance by explaining frame numbering (0 innermost), the effect on subsequent commands, and how to obtain frame numbers via gdb_get_backtrace. It also mentions the prerequisite session_id. However, it does not explicitly state when not to use this tool.

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

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

With no annotations, the description effectively conveys that selecting a thread affects later commands. It mentions the session_id requirement from gdb_start_session. No contradictions or missing critical behaviors.

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

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

The description is two sentences, front-loaded with the primary action, and every sentence adds essential information without redundancy.

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

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

The description fully explains the tool's purpose, prerequisites, and effect on subsequent commands. For a simple selection tool with no output schema, it is complete.

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

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

Schema coverage is 100%, but the description adds value by linking session_id to gdb_start_session and thread_id to gdb_get_threads, providing context 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 action 'select a specific thread' and the resource 'thread'. It is distinct from sibling tools like gdb_select_frame and gdb_get_threads.

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 when to use the tool (to change context for subsequent commands) and refers to gdb_get_threads for thread IDs. It does not explicitly say when not to use it, but the context is clear.

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

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

With no annotations, the description carries the full burden. It mentions return details and covers core behavior but does not discuss error conditions, side effects, or permission needs. It adds some context beyond annotations but is not exhaustive.

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

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

The description is concise with no wasted words, front-loaded with the main action, and structured logically. Each 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?

Given 5 parameters and no output schema or annotations, the description covers the main purpose, return values, and usage guidance. It is reasonably complete for typical use, though lacks error handling details.

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

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

Schema coverage is 100%, but the description adds meaning beyond the schema: it explains location types ('function, file:line, or address') and highlights the hardware parameter. This provides operational context not present in schema descriptions 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 clearly states the verb 'set' and the resource 'breakpoint', specifying three location types: function, file:line, or address. It also mentions conditional, temporary, and hardware-assisted breakpoints, distinguishing it from sibling tools that delete, disable, enable, or list breakpoints.

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 advises using gdb_list_breakpoints to verify and requires session_id from gdb_start_session, providing clear context on prerequisites and verification. However, it does not explicitly mention when not to use or alternatives, but the purpose is specific enough.

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

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

With no annotations provided, the description fully carries the burden. It discloses that warnings are reported in a 'warnings' field, that a session_id is returned and must be used with other tools, and explains the required sequence for core dump symbol resolution (sysroot after core load). This is comprehensive behavioral disclosure.

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

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

The description is somewhat lengthy and mixes parameter listing with usage notes. It could be more structured, perhaps by separating parameter details from procedural notes. While every sentence adds value, the overall flow could be tighter. There is some redundancy with the schema descriptions.

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 complexity of the tool (7 parameters, no output schema, important behavioral nuances), the description covers all necessary aspects: what the tool does, how to use parameters, key warnings, the returned session_id, and critical ordering for core dump debugging. It is complete and effectively supports an AI agent in correct invocation.

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

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

Schema coverage is 100%, but the description adds significant value beyond the schema. For example, it explains the --core flag for core dumps and the important ordering for symbol resolution, provides examples for init_commands and working_dir, and clarifies the use of env. This extra context is highly beneficial for correct usage.

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

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

The description clearly states it starts a new GDB debugging session and lists the actions it can perform (load executable, core dump, init commands). It differentiates from sibling tools (e.g., gdb_set_breakpoint, gdb_continue) by focusing on session initialization. The purpose is specific and unambiguous.

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

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

The description provides clear guidance on when to use the tool (starting a session) and gives important usage notes, especially for core dump debugging with sysroot. It does not explicitly state when not to use or list alternatives, but the context of sibling tools and the session-oriented nature mitigates this. The warnings about critical issues in the response add value.

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 stepping behavior (enters functions) and the prerequisite (paused state). Does not mention side effects or limits, but given the simple nature of stepping, it is transparent enough.

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 front-loaded main action and important note in all caps. No redundant words. Every sentence is necessary and concise.

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

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

Despite lacking output schema, the description sufficiently explains the tool's purpose, prerequisites, and required parameter. Could mention behavior if not paused or timeout implications, but adequate for a straightforward stepping tool.

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

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

Schema covers 100% of parameters. Description adds value by linking session_id to gdb_start_session but does not elaborate on timeout_sec. Baseline 3 is appropriate as schema already documents both 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 clearly states 'Step into the next instruction (enters function calls),' which is a specific verb and resource. It distinguishes from sibling tools like gdb_next (step over) and gdb_continue (resume freely).

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

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

Explicitly states 'Only works when program is PAUSED at a specific location' and 'Use this for single-stepping...' Provides clear context but lacks explicit alternatives or when-not conditions.

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 cover behavioral traits. It mentions 'clean up resources,' implying side effects, but does not detail irreversibility, permissions, or what happens to ongoing debugging.

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

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

The description is a single sentence that conveys all necessary information without wordiness. It is front-loaded and efficient.

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 termination tool with one parameter and no output schema, the description is mostly complete. It could mention return values or error conditions, but the core functionality is clear.

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

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

The input schema already describes the session_id parameter with 100% coverage. The description only adds that it is obtained from gdb_start_session, which adds marginal value beyond the schema.

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

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

The description clearly states 'Stop the current GDB session and clean up resources,' which is a specific verb+resource combination. It is easily distinguished from sibling tools like gdb_interrupt or gdb_continue.

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

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

The description explicitly mentions the prerequisite session_id from gdb_start_session, indicating when this tool should be used. However, it does not explicitly list alternatives or contexts where it should not be used.

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