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

The description adds valuable behavioral context beyond annotations: it mentions 'cleans up associated resources,' which clarifies the scope of the destructive action hinted at by destructiveHint=true. It also notes the return format ('dict: Contains success status and message'), providing output expectations not covered by annotations. No contradictions with annotations exist.

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

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

The description is well-structured and front-loaded with the core purpose, followed by details on behavior, args, and returns. Each sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

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

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

Given the tool's complexity (destructive action with one parameter), annotations cover safety and idempotency, and the description adds behavioral and output details. However, without an output schema, the description could more fully explain return values (e.g., specific keys in the dict). It is mostly complete but has 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 description adds minimal semantics for the single parameter ('The terminal session ID to close'), but schema description coverage is 0%, so the schema provides no details. The description compensates slightly by explaining the parameter's role, but it lacks format or source guidance (e.g., from terminal_list). Baseline is 3 due to low schema coverage and partial compensation.

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

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

The description clearly states the specific action ('Close a terminal session') and resource ('terminal window and associated resources'), distinguishing it from sibling tools like terminal_create_or_get (create/get), terminal_get_output (read output), terminal_list (list sessions), and terminal_send_input (send input). It provides a complete picture of what the tool does.

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 context by specifying it closes a terminal session, suggesting it should be used when a session is no longer needed. However, it does not explicitly state when not to use it (e.g., while actively using the terminal) or name alternatives like terminal_list to find session IDs, leaving some guidance gaps.

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

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

The description adds valuable behavioral context beyond annotations. Annotations indicate readOnlyHint=false (mutation), openWorldHint=true (can create new resources), idempotentHint=true (safe to retry), and destructiveHint=false (non-destructive). The description elaborates on behavior: terminals are 'visible' and user-interactive, commands execute in that window, and it explains the idempotent behavior (returns existing terminal if alive). It does not mention rate limits or auth needs, but provides useful operational details.

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

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

The description is well-structured and front-loaded: the first sentence states the purpose, followed by behavioral details, parameter explanations, return info, and examples. Each sentence earns its place by adding value (e.g., explaining visibility, idempotency, parameter defaults, usage of session_id). 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 moderate complexity (mutation with idempotency), rich annotations, and no output schema, the description is largely complete. It covers purpose, behavior, parameters, returns, and examples. However, it lacks explicit error handling or edge cases (e.g., what happens if terminal name conflicts or working_dir is invalid), and the return dict fields are listed but not fully explained (e.g., what 'platform' means).

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 0% schema description coverage (schema only has titles 'Name' and 'Working Dir'), the description fully compensates by explaining both parameters. It clarifies that 'name' is optional and used for idempotent retrieval, and 'working_dir' is optional with a default (current directory). This adds essential meaning beyond the bare schema, though it could specify format constraints (e.g., path syntax).

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: 'Create a new visible terminal window or get an existing one by name.' It specifies the verb (create/get), resource (terminal window), and distinguishes it from siblings like terminal_close (closing), terminal_get_output (reading output), terminal_list (listing), and terminal_send_input (sending input).

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 when to use this tool: to open or retrieve a visible terminal window. It implies usage through examples (e.g., creating unnamed/named terminals, getting existing ones) but does not explicitly state when to use alternatives like terminal_list for listing or terminal_close for closing, nor does it mention exclusions (e.g., when not to create a new terminal).

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds valuable behavioral context beyond annotations: it explains that output includes both command inputs and outputs, mentions a slight delay due to asynchronous capture, and specifies default/max lines. This enhances understanding of the tool's 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?

The description is well-structured and front-loaded with purpose, followed by detailed sections (Args, Returns, Examples, Note). Every sentence adds value: no repetition or fluff, and information is efficiently organized for clarity.

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 moderate complexity, no output schema, and rich annotations, the description is complete. It covers purpose, usage, parameters, return values, examples, and behavioral notes. The annotations handle safety and idempotency, while the description fills in operational details adequately.

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

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

Schema description coverage is 0%, so the description carries full burden. It effectively explains both parameters: session_id's source (from terminal_create_or_get) and lines' purpose (number to retrieve from the end), default (100), and max (1000). This adds meaningful semantics beyond the bare 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 tool's purpose with specific verbs ('Get the output', 'Retrieves the recent output') and resource ('from a terminal'). It distinguishes from siblings by focusing on output retrieval rather than session management (terminal_create_or_get, terminal_close), listing (terminal_list), or input sending (terminal_send_input).

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: it's for retrieving terminal output, with session_id from terminal_create_or_get. However, it doesn't explicitly state when NOT to use it or name alternatives for similar functions, though siblings suggest distinct purposes.

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

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

The description adds useful behavioral context beyond annotations. Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds that it returns 'all terminal sessions that are currently open and active', specifying scope and state, and describes the return format as a dict with session details, which is valuable since there's no output schema.

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

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

The description is concise and well-structured: it starts with the core purpose, elaborates on scope and return details, and uses clear sentences. However, the 'Returns:' section is slightly redundant with the prior sentence, slightly reducing efficiency.

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 low complexity (0 parameters, no output schema) and rich annotations, the description is mostly complete. It explains what the tool does and what it returns. A minor gap is lack of error handling or edge case info, but overall it provides sufficient context for an agent to use it effectively.

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

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

With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters, as none exist, and focuses on the tool's function and output instead.

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: 'List all active terminal sessions' specifies the verb (list) and resource (terminal sessions). It distinguishes from siblings like terminal_close (close) and terminal_create_or_get (create/get), but doesn't explicitly contrast with terminal_get_output (get output) or terminal_send_input (send input), which are different 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for usage, or exclusions. For example, it doesn't clarify if this should be used before terminal_get_output to identify sessions, or if it's only for monitoring purposes.

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

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

The description adds valuable behavioral context beyond annotations: it notes that commands execute asynchronously, users can see execution in real-time, and results must be retrieved with terminal_get_output. Annotations indicate destructiveHint=true (mutation) and readOnlyHint=false (write operation), which align with the description's 'send' and 'execute' actions, with no contradiction.

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

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

The description is well-structured and front-loaded, starting with a clear purpose, followed by usage notes, args, returns, examples, and a critical note. Each sentence adds value without redundancy, such as explaining asynchronous execution and result retrieval, making it efficient and easy to parse.

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 (destructive, asynchronous execution) and lack of output schema, the description is largely complete: it covers purpose, usage, parameters, returns, and key behavioral notes. However, it doesn't explicitly address error handling or security implications (e.g., command injection risks), leaving 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?

With 0% schema description coverage, the description compensates by explaining both parameters: session_id is 'returned by terminal_create_or_get' and text is 'the text/command to send' that 'will be executed as a shell command'. This adds meaningful semantics beyond the bare schema, though it doesn't detail constraints like text length or session_id format.

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 with a specific verb ('send') and resource ('input to a terminal'), distinguishing it from siblings like terminal_close (closes sessions), terminal_create_or_get (creates/retrieves sessions), terminal_get_output (retrieves results), and terminal_list (lists sessions). It specifies that input is sent to a visible terminal window for 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 explicit guidance on when to use this tool (e.g., to run commands, start servers, or execute Python scripts) and when not to use it (e.g., use terminal_get_output to retrieve results after command completion). It also references terminal_create_or_get as a prerequisite for obtaining session_id, effectively distinguishing it from alternatives.

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