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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the tool creates a persistent side effect and restricts binding to existing/allowed sessions, but it does not explain what happens on conflict, whether 'replace' is needed, how read/input flags affect behavior, or what errors may occur. This is insufficient for a state-changing operation.

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

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

The description is a single concise sentence with no wasted words, and the main action is front-loaded with 'Persist'. It is appropriately compact, though it achieves concision at the cost of explanatory depth.

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 5 parameters, no output schema, no annotations, and persistent side effects, this description is too thin. It omits crucial guidance about parameter semantics, lifecycle behavior, error conditions, and return values, so an agent cannot reliably invoke it correctly without further investigation.

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 must compensate, but it only vaguely maps to 'binding' and 'session'. It adds the constraint that the session must be existing and allowed, but it does not explain 'replace', 'read_enabled', 'input_enabled', or how these interact. Most parameter semantics remain unexplained.

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 action ('Persist a logical binding') and a resource ('existing, allowed tmux session'), distinguishing it from siblings like terminal_unbind or terminal_list_bindings. However, the meaning of 'logical binding' is not elaborated, leaving some ambiguity about what exactly is being bound.

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 the tool—when you want to persist a logical binding to a tmux session—but it provides no explicit guidance about when not to use it, nor does it mention alternatives such as terminal_send_bound or terminal_tail_bound. The agent must infer usage context from the sibling list.

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?

There are no annotations, so the description carries the full burden. It does disclose useful behavioral traits: the capture is sanitized and capped by configuration, and 'Return' suggests a read-only operation. But it omits details about side effects, authentication needs, or what 'sanitized' actually covers.

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 short sentence with no filler. The key qualifiers ('larger', 'sanitized', 'capped by configuration') are front-loaded and every word contributes to the meaning.

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 two parameters, no annotations, no output schema, and a description that ignores parameter semantics, this is too thin. The description leaves start_line semantics, session format, the configuration cap, and the return shape unexplained, and it doesn't clearly position the tool among its siblings.

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

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

Schema description coverage is 0%, and the description adds no meaningful detail about the 'session' or 'start_line' parameters. The parameter names are somewhat self-explanatory, but the description does not explain how start_line affects the capture or what values are valid, so it fails to compensate for the schema's lack of 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 uses a specific verb ('Return') and a clearly scoped resource ('sanitized scrollback capture'). The qualifiers 'larger' and 'capped by configuration' add useful distinguishing detail, but it doesn't explicitly reference a sibling alternative, so it stops short of a 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 word 'larger' implies a comparison to some smaller/default capture and gives a mild hint about when this tool is appropriate. However, the description never explicitly states when to prefer terminal_capture over terminal_tail or other siblings, nor does it give 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 carries the behavioral burden. It does convey that the operation is a non-mutating 'Return' and that it reveals 'current effective permissions,' which is useful context beyond the bare tool name. However, it omits prerequisites, error behavior, and what exactly 'metadata' includes.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to the core meaning, though its brevity leaves some contextual gaps.

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 has no output schema and no annotations, so the description must compensate for that missing context, but it only states the return surface ('binding metadata and current effective permissions'). It does not explain how the binding argument should be specified, what the returned metadata structure is, or how 'effective permissions' are represented, leaving the description incomplete for reliable invocation.

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

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

The only parameter, 'binding', has 0% schema description coverage, and the tool description never mentions the parameter or its expected format. An agent receives no help understanding what value to provide for 'binding' beyond the schema's type and title.

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 ('Return') and a clear object ('binding metadata and current effective permissions'), so an agent can tell this is a read operation for a single binding's details. It does not explicitly contrast with terminal_list_bindings, but the singular 'binding' plus the 'get' naming implies a targeted lookup rather than a list.

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 about when to use this tool versus siblings like terminal_list_bindings, terminal_bind, or terminal_unbind. The description only states what the tool does, not when it should be selected or when an alternative would be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'List', implying read-only, but does not explain whether it shows both persistent bindings and transient session state, whether authentication is required, or whether any side effects occur. The two-part output is a hint but is not elaborated.

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 eight-word sentence with no filler and a front-loaded verb. Every word earns its place, though the meaning is slightly under-specified for a tool family with many closely related siblings.

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 zero parameters and an output schema present, the description covers the core invocation: calling the tool requires no arguments. However, without annotations or context clarifying what 'current session state' includes and how it differs from terminal_status, the entry is not fully complete for an agent choosing among many terminal 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?

This tool has zero parameters and an empty input schema, so there are no parameter semantics to describe. The baseline of 4 for zero-parameter tools applies; the description correctly avoids inventing parameter details.

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 ('persistent logical bindings' and 'current session state'), clearly indicating a read operation. It is not a tautology and distinguishes from tools like terminal_get_binding and terminal_bind, though it does not explicitly contrast with terminal_status or terminal_list_sessions.

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 siblings such as terminal_list_sessions or terminal_status. There is no mention of use cases, prerequisites, or when not to use it, leaving the agent to infer context from the tool name and sibling list.

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 present, so the description carries the burden. It discloses important behavioral constraints: only whitelisted sessions are returned and denied session details are hidden, which is non-obvious and safety-relevant. It doesn't mention output format or error behavior, but for a read-only list tool 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?

A single sentence with no filler; the key behavioral scope is front-loaded. Every word contributes meaning, making it exceptionally 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 zero-parameter, read-only list operation the description is mostly complete: it defines the result set (whitelisted sessions) and a privacy guarantee. Lacking an output schema, it doesn't describe the per-session fields returned, which is a minor gap, but not enough to penalize heavily.

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 takes zero parameters, and the schema's 100% coverage makes further elaboration unnecessary. Baseline for zero-param tools is 4; description doesn't need to add anything.

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

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

States a specific verb ('List') and resource ('whitelisted tmux sessions'), and adds a scope limiter ('without exposing denied session details'). This distinguishes it from generic listing tools and sibling tools like terminal_status or terminal_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?

The description implies its use for enumerating sessions but gives no explicit when-to-use vs alternatives. With siblings like terminal_status or terminal_list_bindings, an agent could benefit from a hint about when to prefer this tool, but the purpose is clear enough to infer.

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 behavioral burden. It usefully discloses that sending only works when global and binding input are enabled and that input is literal. However, it does not explain what happens if those inputs are disabled, whether press_enter is applied, or any 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?

A single tight sentence that front-loads the core action, covers the literal-text behavior, and states the enabling condition. There is no redundant wording.

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 three parameters, no annotations, and no output schema, this description is too thin. It omits the role of 'binding', the press_enter option, the behavior when the enabling condition is false, and any return value or confirmation information.

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 must compensate for all three parameters. It clarifies that 'text' is literal and suggests 'binding' relates to the binding-enabled condition, but it gives no meaningful explanation of 'binding' as a parameter and completely omits 'press_enter'.

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 action and resource: 'Send literal text' subject to a clear condition ('only when global and binding input are enabled'). It distinguishes the tool from key-sequence senders by emphasizing 'literal text', though it does not explicitly name 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 phrase 'only when global and binding input are enabled' provides a clear precondition, and 'literal text' hints at when this tool is appropriate. However, it does not explicitly contrast with terminal_send_text or terminal_send_keys, nor does it give when-not-to-use guidance.

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 behavioral burden. It discloses the allowlist restriction and the enablement gate, which are meaningful behavioral constraints. However, it does not say what happens if a key is not allowlisted or if terminal_input is disabled, nor any 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, front-loaded sentence with no unnecessary words. It communicates the essential constraint and condition without 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?

For a tool with zero annotations, no output schema, and no parameter explanations, the description leaves important gaps: how to identify allowlisted keys, what happens when terminal_input is disabled, and expected return behavior. The condition provided is useful but not sufficient for 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 description coverage is 0%, so the description must compensate for the schema's bare parameter names. It gives a hint that 'keys' are tmux keys, but it does not explain allowed key formats, what 'session' refers to, or how the allowlist is determined.

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 ('Send'), the object ('tmux keys'), and the key scope ('only allowlisted'), plus a condition. This distinguishes it from sibling tools like terminal_send_text, though it does not explicitly name the alternative.

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 a prerequisite ('when terminal_input is enabled in local config') but gives no guidance on when to choose this tool over siblings such as terminal_send_text or terminal_send_bound. No alternatives or exclusions 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, the description carries the full behavioral burden. It does disclose two key traits: it sends literal text (not interpreted sequences) and requires terminal_input to be enabled locally. However, it does not explain what happens when the config is disabled, whether press_enter affects the sent text, or whether this is a mutating action with 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 entire definition is one sentence with zero filler. It front-loads the action ('Send literal text') and then states the key precondition. Every word adds value.

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 that there is no output schema, no annotations, and 3 parameters, the description is too minimal. It does not tell the agent what a successful call returns, how press_enter behaves, what session refers to, or what error occurs when terminal_input is disabled. This is insufficient for an agent to invoke the tool confidently in diverse scenarios.

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 must compensate for missing parameter docs. The phrase 'literal text' clarifies the text parameter. But session and press_enter remain entirely unexplained, leaving the agent to guess at their meaning and 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 states a specific verb ('Send') and resource ('literal text' to a terminal), and adds the qualifier 'only when terminal_input is enabled.' This makes the tool's purpose clear. However, it does not explicitly distinguish it from the sibling terminal_send_keys, so the differentiation is only implied through the word 'literal.'

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 clear precondition: use this tool only when terminal_input is enabled in local config. It does not mention when not to use it or name alternatives like terminal_send_keys, so an agent has to infer when the other tool would be more appropriate.

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 behavioral disclosure burden. It mentions an 'explicit heuristic reason' as an output trait, but it does not state whether the tool reads only, what side effects it may have, what the classification categories are, or how it handles disallowed 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?

The description is a single compact sentence with no redundant filler. It front-loads the action and resource, though some terms like 'allowed' and 'explicit heuristic reason' could be clearer.

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

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

With no output schema and no annotations, the description must fully explain the operation and its result. It gives only a high-level notion of classification, leaving out the return format, possible classification values, and input requirements. An agent could infer intent but would struggle to call it correctly and interpret the result.

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 needs to compensate. It identifies the parameter as a tmux session, but it does not clarify whether the session value should be a name, an ID, a path, or an index, nor does it explain the 'allowed' constraint.

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 does state a verb ('classify') and a resource ('an allowed tmux session'), so the basic purpose is present. However, 'allowed' is undefined, 'classify' is vague about what dimensions are being classified, and the description does not distinguish terminal_status from its sibling terminal_status_bound.

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?

There is no guidance about when to use this tool versus alternatives such as terminal_status_bound or terminal_list_sessions. The phrase 'an allowed tmux session' implies some restriction, but it does not explain what makes a session allowed or how this relates to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'classify.' It does not state whether the operation is read-only, whether it can modify session state, how invalid or missing bindings are handled, or what side effects might occur. This is insufficient for an agent to predict the tool's behavior safely.

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 concise sentence with no filler words, and the key idea of 'logical binding' is front-loaded. However, the brevity comes at the cost of necessary detail, so it earns high marks for conciseness but not a perfect score.

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, the description should explain what 'classify' returns or what status categories exist, but it does not. It also lacks mention of error cases, resolution behavior, or how this compares with sibling tools. The tool is simple (one parameter), but the description still leaves critical operational 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 input schema provides only the parameter name 'binding' with no description, and the description also fails to explain what forms a logical binding can take, how it should be formatted, or how it resolves to a session. The phrase 'logical binding' adds minimal context but does not compensate for 0% schema description 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 names a specific resource (tmux session) and a distinguishing mode (resolved by a logical binding), which helps separate it from plain terminal_status. However, the verb 'classify' is vague and never explains what classification is being performed or what the outcome looks like. It is better than a tautology but leaves the core action ambiguous.

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 'resolved by a logical binding' implies this tool is for cases where a binding, rather than a direct session reference, is available. However, there is no explicit guidance about when to choose terminal_status_bound over terminal_status, terminal_get_binding, or terminal_tail_bound, and no exclusions are stated.

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

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

With no annotations, the description carries the behavioral burden. It discloses that output is sanitized and limited to allowed sessions, which is useful, but it does not explain what sanitization removes, what happens for disallowed sessions, or whether this is a pure read operation beyond the word 'Return'.

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 with no unnecessary words, and the purpose is front-loaded. It sacrifices detail for brevity, but as a concise statement of the tool's core action it is 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 tool with no annotations and no output schema, the description is too thin. It omits the meaning of `lines`, the behavior of sanitization, how to identify an allowed session, and how this differs from sibling tools. An agent would struggle to invoke it correctly with only this description.

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 needed to compensate. It relates `session` to a tmux session and implies recency, but it does not explain the `lines` parameter, the default value of 200, or any constraints. The description adds little beyond what the parameter names already communicate.

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 ('Return') and identifies a distinct resource: sanitized recent output from an allowed tmux session. It distinguishes the tool from a raw capture at a basic level, but it does not explicitly contrast it with siblings like terminal_capture or terminal_tail_bound.

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?

There is no guidance on when to use this tool instead of terminal_capture, terminal_status, or terminal_tail_bound. The description implies a use case (viewing recent output) but does not state exclusions or alternatives, so an agent would have to infer the appropriate selection.

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 of behavioral disclosure. It only reveals that the output is sanitized, with no mention of whether resolution can fail, what sanitization strips, whether the operation has side effects, or what happens when the binding does not 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 a single sentence with no filler, and the main verb and object are front-loaded. It loses points only because the unexplained term 'logical binding' makes the sentence less informative than it appears.

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 2-parameter tool with no annotations and no output schema, the description is under-specified. It does not explain the meaning of 'lines', the nature of the binding, the returned output format, or how this tool relates to terminal_tail and terminal_get_binding — all of which an agent would need to call it 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 0%, so the description must compensate. It clarifies that 'binding' is resolved logically, but it says nothing about the 'lines' parameter — not even that it controls the number of output lines — and does not specify the binding's format or namespace.

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 identifies a specific operation — returning sanitized output after resolving a binding — but relies on the unexplained term 'logical binding' and does not distinguish this tool from siblings like terminal_tail or terminal_get_binding. It is not a tautology, but the purpose is too vague for reliable selection.

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 for when to use this tool versus alternatives. The name hints that it tails output for a bound target, but the description never states a use case, precondition, or exclusion, leaving the agent to infer the appropriate 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?

There are no annotations, so the description carries the full burden. It discloses one meaningful behavioral trait: the deletion does not change the tmux session, which is valuable context. However, it remains silent on side effects, whether the deletion is reversible, idempotency, or what happens to active bound commands.

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

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

The description is a single, front-loaded sentence with no filler words. It delivers the core action, target resource, and an important qualifier in minimal space.

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 annotations and no output schema, the one-line description is too sparse. It does not define what constitutes a logical binding, where to obtain one, whether deletion is permanent, or how the tool interacts with related bind/unbind siblings. An agent is left to infer too much from the name and schema.

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 has only a required 'binding' string with no description, and the description does not explain the parameter beyond calling it a 'logical binding'. It adds a small amount of meaning by labeling the binding as logical rather than a tmux construct, but offers no format, examples, or guidance on how to specify the binding value, leaving a 0% schema-coverage gap largely uncompensated.

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 and resource: 'Delete a logical binding'. It also adds a distinctive scope condition, 'without changing its tmux session', which separates it from direct tmux-level unbinding operations and aligns with the delete/inverse counterpart of terminal_bind.

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 should be used when a logical binding needs to be removed, but it does not explicitly mention alternatives or when-not-to-use conditions. Sibling tools like terminal_bind and terminal_get_binding are present but not referenced, so an agent must infer the appropriate context from the name and one-line description.

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