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

With no annotations, the description carries the behavioral burden. It explicitly states that closing sends SIGTERM to the process in the pane, which reveals the mechanism and that this is a real process termination. It does not mention the force/SIGKILL fallback or post-close state, but the core destructive effect is clearly disclosed.

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 short sentences with no filler; the primary purpose is front-loaded, and the second sentence adds the signal detail. 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?

The tool is simple, has full schema coverage, and the core action and effect are described, so an agent can invoke it with the required name. However, there is no output schema, no error/return behavior, and no guidance on how this differs from terminal_send_signal, leaving some operational context missing.

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

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

Schema coverage is 100%, so the schema already documents both parameters ('Terminal name to close', 'Force kill with SIGKILL...'). The description only reinforces the name parameter via 'by name' and adds no new semantics for force or default behavior, so the baseline 3 applies.

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

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

The description uses a specific verb ('close'), names the resource ('terminal session'), and adds the 'by name' scoping plus the concrete effect (SIGTERM to the pane's process). This clearly separates it from siblings like terminal_spawn or terminal_send_signal.

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 the tool is for ending a named terminal session, but it never explicitly states when to prefer it over terminal_send_signal or how it differs from other terminal lifecycle tools. No selection criteria or alternatives are given, leaving usage to inference.

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 the tool's behavioral profile. 'List' implies a read-only operation, and the described output fields add useful specificity, but the description does not disclose potential limitations, session scoping, or whether the list is global to the workspace.

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 filler. The main action and resource are front-loaded, followed by a compact list of the returned fields.

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 parameterless list tool, the description provides sufficient context: it names the return contents and the target resource. There is no output schema, so slightly more detail about the response structure could help, but the core invocation needs are fully covered.

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

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

The tool has zero parameters, so the baseline is 4 and parameter semantics are not a concern. The description adds value by clarifying what data is returned for each session, even though no input semantics are needed.

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

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

The description states a specific verb ('List') and a clear resource ('all active terminal sessions'), and enumerates the returned fields: names, PIDs, working directories, and current commands. This differentiates the tool from mutating siblings like terminal_close and terminal_send.

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 the tool is for enumerating active terminal sessions, but it does not explicitly say when to use it versus alternatives such as terminal_snapshot or terminal_read. No exclusions or sibling comparisons are provided, so the usage context is only inferred.

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 behavioral disclosure burden. It reveals that output is limited to the last N lines and that ANSI codes are stripped, which is behavior beyond what the schema states. It does not mention side effects, but as a read operation this is an acceptable level of 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 a single sentence that front-loads the core action and resource, then adds the two most decision-relevant details (line limit and ANSI stripping). Every word contributes, with no repetition or filler.

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

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

For a low-complexity tool with no output schema, the description adequately explains what is returned ('last N lines', 'ANSI codes stripped'). It does not specify the exact return structure (e.g., array of strings vs joined string) or error behavior for a missing terminal, but these are minor gaps for an agent invoking this tool correctly.

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

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

Schema description coverage is 100%, so both parameters (name, lines) are already well documented. The description adds some context about how the 'lines' parameter relates to output but does not meaningfully go beyond the schema. A baseline score of 3 is appropriate when structured data handles parameter 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?

The description uses a specific verb ('Read'), identifies the resource ('current visible output from a terminal session'), and adds precise detail ('last N lines', 'ANSI codes stripped'). This clearly distinguishes it from sibling tools like terminal_send (write) or terminal_snapshot (full state capture).

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

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

No guidance is given on when to use this tool versus alternatives such as terminal_snapshot or terminal_wait. The description implicitly suggests it is for reading output, but it does not state exclusions, prerequisites, or conditions that would route an agent to a different sibling.

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 states the resize action but does not disclose what happens if only 'name' is provided (width/height are optional per schema), whether the resize persists, how it affects pane contents, or failure behavior. For a mutating tool this is a noticeable gap.

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

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

A single sentence that front-loads the action and adds a brief rationale. Every word earns its place; there is no fluff, repetition, or boilerplate.

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 three parameters, no output schema, and no annotations, the description is adequate for basic invocation but leaves ambiguity about optional-parameter behavior (e.g., resizing with only 'name') and the lack of a return value. It is functional but not thorough.

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

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

Schema description coverage is 100%, so the schema already documents the 'name', 'width', and 'height' parameters. The description adds no parameter-level detail beyond that, which meets the baseline of 3 but does not exceed it.

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 ('Resize') with a clear resource ('a terminal pane'), immediately distinguishing it from siblings like terminal_close, terminal_list, terminal_send, terminal_read, terminal_snapshot, and terminal_wait. The parenthetical adds practical context without obscuring the core action.

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

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

The description gives a concrete usage context: 'useful before reading output from width-sensitive programs'. This implies when to use it, but it does not explicitly state when not to use it or name alternatives. Clear context with no exclusions earns a 4.

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 alone must disclose behavioral traits. It mentions keystokes and named sessions, but does not say that input is sent without reading output, whether failed sends produce errors, or what side effects occur. For a tool that can execute commands, this lack of behavioral disclosure is a material gap.

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

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

The description is short and front-loaded, stating the action first and use cases second. Every sentence earns some place, but the 'or send signals' clause is redundant with the sibling terminal_send_signal and introduces ambiguity, so it is not perfectly tight.

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

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

The tool is simple and has a fully documented schema, but there is no output schema and no annotations. The description does not clarify how to coordinate with terminal_read, how to handle the default Enter behavior in practice, or how sending signals via this tool differs from terminal_send_signal. It is adequate but not complete.

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

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

Input schema coverage is 100%, so each parameter is already described in the schema. The description adds some semantic context by mentioning typing commands and answering prompts, which helps clarify the `input` parameter, but it does not add significant meaning 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 uses a specific verb-resource pair: 'Send input (keystrokes) to a named terminal session.' It clearly conveys the core action and distinguishes the tool from read, spawn, close, and resize siblings. However, the phrase 'or send signals' blurs the boundary with the sibling tool terminal_send_signal, preventing a full 5.

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 use cases such as typing commands, answering prompts, or sending signals, which gives an agent some context for when to invoke it. It does not explicitly state when to choose terminal_send_signal instead, despite that sibling existing, so the guidance is incomplete and slightly misleading.

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 burden of behavioral disclosure. It explains the immediate effects of signals (interrupt, suspend, EOF), which is useful, but it does not mention session state changes, error behavior, whether the session must already exist, or other 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, focused sentence that front-loads the core action and immediately supplies meaningful examples. There is no redundancy or unnecessary elaboration.

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 two-parameter tool with an enum and no output schema, the description is adequate but not fully complete. It does not mention how to obtain the terminal name, whether the terminal must be active, or what happens after a signal is sent, leaving some gaps for an agent to infer from sibling tools.

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

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

The schema already provides 100% coverage for both parameters, including descriptions and an enum with signal meanings. The tool description adds examples but mostly duplicates what the schema already explains, so it does not significantly expand parameter understanding beyond the schema baseline.

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

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

The description clearly states a specific action ('Send a signal to a terminal session') and provides concrete examples (Ctrl+C, Ctrl+Z, Ctrl+D) that make the tool's purpose identifiable. It is sufficiently distinguished from the sibling terminal_send by focusing on control signals rather than input, though it does not explicitly name the sibling.

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 by listing signal purposes such as interrupt, suspend, and EOF, giving an agent a sense of when the tool is appropriate. However, it does not explicitly state when to prefer this tool over alternatives like terminal_send or terminal_close, nor does it mention any exclusions.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. 'Snapshot' implies a non-destructive read, but the text never explicitly states that it does not modify terminal state or consume output. It also doesn't mention potential performance cost of scanning all sessions.

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 action, scope, content, and use case are all delivered up front without redundancy.

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

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

For a zero-parameter, no-output-schema tool, the description adequately covers what it does and what information it returns. It could be slightly stronger by explicitly noting the output format or confirming that no state changes occur, but these are minor gaps.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter details, but none are needed since the schema confirms there is nothing to configure.

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 ('take a snapshot') naming a clear resource ('all terminals') and lists the captured contents (names, commands, last few lines of output). This clearly distinguishes the tool from siblings like terminal_read (single terminal) and terminal_list (likely just names/IDs).

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

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

The phrase 'useful for getting an overview of what's happening across all sessions' gives clear context for when to use it. However, it does not explicitly state when not to use it or point to specific alternatives such as terminal_read for inspecting one terminal in detail.

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 behavioral burden. It adds meaningful behavioral detail: background mode auto-allows safe tools, blocks destructive git commands and rm -rf, and resume reuses existing sessions. It does not mention duplicate name handling or whether the command blocks, but the disclosed mode behavior is substantial.

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 core sentence is front-loaded, and the mode details are organized into a compact bulleted list. Each section earns its place, though the description is slightly longer than strictly necessary for a spawn 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?

The description is strong on modes and parameter semantics, but gaps remain: it does not explain what happens if the session name already exists, whether the optional command runs asynchronously, or what the tool returns after spawning. With no output schema and no annotations, these are relevant gaps for an agent invoking a creation 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 description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining each mode's exact safety behavior and when to use it, especially for 'background' and 'resume'. This pushes parameter semantics above the schema-only baseline.

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 a concrete action and resource: 'Spawn a new named terminal session.' It also states optional directory and immediate command execution, which makes the tool's purpose clear. It does not explicitly contrast with sibling tools, but 'new' and 'spawn' make it distinguishable from terminal_send, terminal_read, and terminal_close.

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

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

The description gives explicit mode-selection guidance: 'interactive' is default, 'background' is 'best when you want autonomous work with guardrails', and 'resume' resumes an existing session. It does not discuss when to use this tool versus the other terminal lifecycle tools, but for a spawn action the mode guidance is the key usage decision.

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 it delivers. It discloses the polling cadence (every second), the timeout cap, the special early-return condition for permission prompts (with a concrete example string), and the full set of return statuses with their meanings. This is exactly the behavioral depth an agent needs to predict tool behavior without executing it.

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

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

Three tight paragraphs where every sentence earns its place: core purpose and polling behavior first, the special permission-prompt behavior second, and a compact enumeration of return statuses third. There is zero fluff, zero repetition of schema content, and the most decision-relevant information is front-loaded.

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

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

For a tool with no output schema and no annotations, the description must document return values — it does, enumerating found/permission_needed/timeout with meanings. Minor gaps remain: error behavior for an invalid terminal name or pattern is unaddressed, and the phrase 'JSON-like status' is imprecise about the exact response shape, which could cause parsing ambiguity 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?

Schema description coverage is 100%: every parameter (name, pattern, timeout, interrupt_on) already has a clear schema description including defaults, bounds, and matching semantics. The description adds minor linkage — e.g., how pattern relates to the 'found' status and how interrupt_on defaults to permission prompts — but the schema does the heavy lifting, so baseline 3 is appropriate.

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

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

The first sentence states a specific verb and resource: 'Wait for a terminal to show specific output.' It adds the polling mechanism (every second up to timeout), which cleanly distinguishes it from sibling tools like terminal_read or terminal_snapshot — none of which block-and-wait. An agent can immediately know what this tool is for and what it is not.

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

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

The usage context is implied rather than stated: the permission_needed status and 'so the conductor can approve' hint at an orchestration flow, but the description never explicitly says when to use this versus alternatives like terminal_read or terminal_snapshot, nor does it mention a canonical flow such as 'send a command, then wait for its output.' No exclusions or when-not-to-use guidance is given.

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