terminal-mcp

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

With no annotations, the description carries full burden. It explicitly discloses the escalation strategy (sends EOF, then SIGHUP, then SIGKILL), which goes beyond a simple 'terminate' and informs the agent about potential forceful behavior. This is valuable context for an AI agent.

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

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

The description is extremely concise—two sentences, no filler. Every word serves a purpose, and the critical behavioral detail is front-loaded. It achieves maximum clarity with minimal 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 tool with one required parameter and no output schema, the description adequately covers the core behavior. A minor gap is the lack of information about the return value or error states, but given the tool's simplicity, it is substantially 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%; the schema already describes the only parameter ('Session ID to close'). The description adds no additional meaning or usage constraints for this parameter, so a baseline score 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 action ('Terminate') and the resource ('a session'). The details on the termination sequence (EOF, SIGHUP, SIGKILL) differentiate it from sibling tools like session_resize, session_list, etc., making 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 guidance is provided on when to use this tool versus alternatives (e.g., session_interact, session_exec). There is no mention of prerequisites or conditions under which closing is appropriate. The description only states what it does, not when to choose 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 provided, the description carries the full burden. It discloses the persistent nature of the session and that snapshot mode is always available, which are key behavioral traits. It could add details about resource usage or cleanup requirements, but the disclosed info is sufficient for safe invocation.

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 at two sentences, but the second sentence could be streamlined (e.g., 'Supports interactive shells, SSH, REPLs, and database CLIs.' is a bit broad). Overall, every sentence contributes meaning without redundancy.

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

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

Given the complexity of the tool (7 parameters, no output schema) and the lack of annotations, the description provides a solid understanding of what the tool does and the returned session_id. It could be more complete by noting that the session persists until explicitly closed or the idle_timeout expires, and that commands are executed in a new terminal environment. However, the given info is mostly 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 description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds value by explaining that 'enable_snapshot' is deprecated (though kept for backward compatibility) and clarifies that snapshot is always enabled. This extra context goes beyond what the schema provides, justifying a score above the baseline of 3.

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

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

The description clearly states the tool spawns a persistent PTY terminal session and returns a session_id, which is the core purpose. It explicitly distinguishes itself from sibling tools by noting that the returned session_id is used by all other session_* tools, making the relationship to siblings clear.

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

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

The description provides clear context for usage with examples (interactive shells, SSH, REPLs, database CLIs) and notes the session_id is used by sibling tools, implying this is the first tool to call. However, it does not explicitly state when NOT to use it (e.g., for non-interactive scripts) or mention alternatives beyond 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?

With no annotations provided, the description carries full burden. It states that the session is 'temporary' and 'automatically cleaned up after execution,' which tells the agent the session has a short lifecycle. However, it omits important behaviors: what happens on timeout (partial output vs. error), how truncation affects returned data, whether state is preserved between executions, or that cleanup means the session cannot be reused. Given zero annotations, more behavioral context is expected.

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 two sentences, totaling 20 words. It immediately states the core action and outcome, then adds one critical piece of lifecycle information. Every word earns its place with no redundancy 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?

Given the tool's complexity (6 parameters including enums, no output schema), the description is too sparse. An agent needs to know: what happens on timeout, the format of returned output, whether stderr is captured, and how truncation modes differ. Since there is no output schema, the description should compensate by summarizing return behavior.

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 each parameter already has a description in the schema. The tool description adds no additional semantic context beyond what the schema provides. The baseline of 3 is appropriate because the description does not explain how parameters interact (e.g., how truncation modes affect output, or that cols/rows are only meaningful for interactive programs).

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 'Execute a command in a temporary session and return the output,' which specifies the action (execute), the resource (temporary session), and the result (return output). This differentiates it from sibling tools like session_send (which sends input without returning final output) and session_read (which reads existing output). The addition of 'temporary' and 'automatically cleaned up' adds valuable distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives like session_interact, session_send, or session_read. It doesn't explain that this is a one-shot execution tool suitable for quick commands, while session_interact is for ongoing interaction. No prerequisites, when-not-to-use, or behavior for long-running commands is 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. It discloses the combined send+read behavior and optional wait_for, but omits key behavioral traits: the effect of the 'confirmed' parameter for bypassing dangerous command gates, how input/key/control_char interact, error handling, or what happens on timeout. The mention of halving round trips is a performance note, not a behavioral trait. The description is adequate but incomplete.

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 core purpose, no filler. Every word earns its place. The structure is efficient and to the point.

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 12 parameters, 9 sibling tools, no output schema, and no annotations, the description is far too minimal. It does not explain parameter interactions, what the output looks like, how it relates to siblings like session_send, session_read, or session_exec, or how to handle the 'confirmed' gate. A tool of this complexity requires more context to be fully usable.

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 baseline is 3. The description adds no new meaning to individual parameters—'Optionally waits for a regex pattern' restates the wait_for schema description. It does not explain inter-parameter relationships (e.g., input vs. key vs. control_char mutual exclusivity) or the implications of confirmed, read_mode, or truncation. No additional value over the schema.

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

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

The description clearly states the verb ('Send input and read output'), resource ('call' on a session), and distinguishes from siblings by noting it combines session_send and session_Read, halving round trips. This meets the 'specific verb+resource' criterion and differentiates from sibling tools.

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

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

The description implies when to use this tool (when you need both send and read in one call to halve round trips) and mentions optional regex waiting, suggesting an alternative to using separate session_send, session_read, and session_wait_for. However, it does not explicitly state when not to use it or list exclusion cases, which keeps it from a 5.

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 and clearly states the tool is read-only ('List all active terminal sessions') and specifies the output fields (status, idle time). This is sufficient for a simple listing operation, though it omits potential details like permissions or whether the list is real-time.

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 of 10 words with no filler. Every word adds value: the verb, the resource, and the output specifics are all present. This is an example of ideal conciseness.

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 has no parameters, no output schema, and no annotations, the description adequately covers its purpose and return content. There are no missing pieces for the agent to understand its basic function.

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 and 100% coverage, so the baseline is 4. The description adds no parameter information because none is needed; it simply describes what the tool returns without requiring any input.

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 ('List') and resource ('active terminal sessions') along with the output details ('status and idle time'). This clearly distinguishes it from sibling tools like session_create, session_send, or session_read, which perform actions on individual sessions rather than merely listing 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?

While the description implies that this tool is used to obtain a list of active sessions (e.g., before acting on a session), it does not explicitly state when to use it versus alternatives, nor does it provide cues such as 'use this to get session IDs for other tools'. The guidance is purely implicit from the tool name and sibling 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?

Given no annotations, the description partially discloses behavior by explaining mode auto-detection for TUI applications and diff mode returning only changed lines. However, it does not explicitly state that this is a read-only operation (non-destructive) or mention any side effects, rate limits, or 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 description is two sentences, front-loaded with the primary purpose, and every clause contributes meaning. No redundant or vague phrasing.

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

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

With 6 parameters (some mode-specific) and no output schema, the description is too sparse. It does not explain parameter interactions (e.g., timeout only in stream mode, scrollback only in snapshot), truncation, or return format. More detail is needed to fully guide correct usage.

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 that 'auto' auto-detects TUI applications and that 'diff' returns only changed screen lines, which is not fully detailed in the schema's parameter descriptions. It does not cover other parameters but that is acceptable given schema completeness.

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 'Read' and resource 'output from a session', defining the tool's core function. It also explains key modes ('auto', 'diff') that distinguish it from sibling tools like session_send or session_create, which handle other session operations.

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 does not provide any guidance on when to use session_read versus alternative tools (e.g., session_list, session_interact). It only describes internal mode behavior, leaving the selection context implicit. No exclusions or prerequisites 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 full burden. It discloses the SIGWINCH signal sent to the process, which is a critical behavioral detail not evident from the schema. It does not mention other potential effects (e.g., screen refresh) or prerequisites, but the information given is valuable.

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 at two short sentences. The first sentence clearly states the main action, and the second sentence adds a key behavioral detail. There is no 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 simple resize operation with well-documented parameters and no output schema, the description is nearly complete. It covers purpose, parameter usage (via schema), and adds the signal behavior. Minor gaps like error conditions or size limits do not significantly impair an agent's ability to use the tool correctly.

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

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

Schema description coverage is 100% with clear parameter descriptions (e.g., 'New terminal width in columns'). The tool description only restates the overall purpose and does not add additional meaning or constraints to the parameters beyond what the schema already provides.

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

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

The description clearly states the verb 'Resize' and the specific resource 'terminal window of an active session', and uniquely identifies the operation among sibling tools like session_create, session_send, etc. The additional detail about sending SIGWINCH further clarifies the mechanism.

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 when needing to adjust terminal dimensions of an active session, but provides no explicit guidance on when to use this tool versus alternatives or when not to use it. However, siblings are sufficiently distinct that confusion is unlikely.

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. It explains the modes of input but does not disclose critical behavioral traits such as whether sending certain inputs is destructive, what happens if the session is inactive, or the implications of the 'confirmed' parameter bypassing a dangerous command gate. The password parameter's logging note is a minor positive, but overall transparency is low.

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 with no wasted words. The first sentence states the core purpose, and the second provides concrete usage examples for the two parameter families. Excellent front-loading of essential information.

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

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

Given the tool has 7 parameters and no output schema, the description is relatively lean. It covers the three input modes but lacks explanation of the 'confirmed' parameter's role, the 'press_enter' default behavior, return value, or error conditions. While adequate for straightforward use, more details would improve completeness.

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

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

With 100% schema description coverage, the baseline is 3. The description adds value by mapping control_char values to signals (e.g., 'c' for Ctrl-C) and key enum values to special keys, which clarifies intent beyond the schema's enum lists. This extra context justifies a 4.

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

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

The description clearly states the tool sends input text, control characters, or special keys to an active session. It uses a specific verb-resource pair and distinguishes the action from sibling tools like session_read or session_exec, which handle output or command 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 guidance on how to use the parameters (e.g., 'Use control_char for signals... Use key for special keys...') but does not specify when to choose this tool over alternatives like session_exec or session_interact. No explicit when-not-to-use or context for excluding other tools is given.

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 fully disclose behavior. It does state the core mechanism (reading output, waiting for pattern or timeout). However, it lacks details on what happens on timeout (e.g., error vs partial output), whether output is returned in full or incrementally, and how parameters like truncation and strip_ansi affect the behavior. The baseline is adequate but leaves gaps.

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, front-loading the core purpose and then adding usage guidance. Every word is informative and necessary. No redundancy or verbosity.

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, no output schema, and no annotations, the description is moderately complete. It explains the tool's function and when to use it, but does not describe return values or behavior in edge cases (e.g., timeout, truncation effects). Without an output schema, the description should provide more details on what the agent can expect as 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 coverage is 100%, so the schema already documents all parameters. The description adds no extra semantic information about parameters—such as pattern format, timeout units, or truncation modes. It provides no value beyond the schema, meeting the baseline but not exceeding 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 clearly states the tool reads output from a session until a regex matches or timeout expires. It also explicitly distinguishes from session_read by specifying when to use this alternative, making the purpose and differentiation very clear.

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

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

The description gives direct usage guidance: 'Use this instead of session_read when you know what output to expect.' This implies the appropriate context. However, it does not explicitly mention when NOT to use (e.g., for continuous reading without a pattern) or provide scenarios for alternatives beyond session_read.

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