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 does state this is a read-only informational tool ('get the shell command...a human can run'), which implies it doesn't mutate tmux state. However, it doesn't disclose edge cases like what happens if the agent has no pane yet, whether the command needs to be run in a specific environment, or format of the returned command. There is no contradiction with annotations.

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 conveys the complete purpose with no wasted words. Every element earns its place - it identifies the action, the resource, the audience, and the mechanism (shell command) efficiently.

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 1-parameter, no-output-schema tool, this is reasonably complete. However, given no annotations and zero schema description coverage, it could benefit from a bit more context - e.g., pointing to tmux_list_agents for finding valid agent IDs, or noting that this is a read-only operation distinct from execution tools. The core purpose is clear but supporting details are thin.

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 1 parameter (agent) with 0% description coverage, meaning the description must explain the parameter's meaning. The description implies 'one agent's live pane' maps to the agent parameter, but it doesn't explicitly state that the agent value must match an already-registered agent name or explain how to discover valid values. Partial compensation for the coverage gap.

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

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

The description clearly states the verb (get) and resource (the shell command a human runs to attach a terminal to one agent's live pane). It distinguishes this tool from siblings like tmux_send and tmux_open_claude by making clear this only produces an attach command rather than executing an action. However, it doesn't explicitly contrast with 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 usage context (when you need to tell a human how to attach to an agent's pane) but provides no explicit when-to-use guidance or exclusions. It doesn't name alternatives or state when NOT to use this tool, relying on the reader to infer that this is for retrieval rather than action.

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 does add one useful behavior detail ('Each recipient's pane updates instantly'), which gives some real-time/push semantics. However, it does not disclose whether the sender receives delivery confirmation, whether delivery is guaranteed, error behavior, or potential side effects like message flooding—only a single minor behavioral trait for a broadcasting tool.

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

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

Two concise sentences with the key behavioral trait front-loaded. No wasted words, but the second sentence ('Each recipient's pane updates instantly') could arguably be folded into a single sentence without loss.

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?

A 2-parameter broadcast tool with no annotations, no output schema, and 0% schema description coverage needs more. The description doesn't explain the 'from' semantics, delivery guarantees, whether the sender can be an unregistered ID, or distinguish the broadcast from tmux_send. For a messaging tool involving agents, the description is thin on operational context.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It does not explain what 'from' should contain (e.g., is it the sender's name, a registered agent ID?) or the format/content constraints of 'body' beyond the schema's minLength. Both parameters' meaning is left to the agent to infer from parameter names alone.

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

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

The description clearly states the verb (send) and resource (message to every registered agent), and distinguishes it from a point-to-point send by noting 'except the sender'. It doesn't explicitly name the sibling alternative (tmux_send), but the 'every registered agent' scope clearly separates it from a targeted 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 broadcast use ('every registered agent') versus targeted messaging, but does not explicitly state when to prefer this over tmux_send, nor does it mention any prerequisites like needing to be registered or how agent registration works. Context is clear but exclusions/alternatives are not named.

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. The description clarifies that this is a read operation ('Fetch') and establishes the source-of-truth relationship to the tmux pane, which is useful context about data consistency. However, it doesn't disclose pagination behavior, whether the limit parameter truncates, ordering of results, or performance characteristics.

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, tight sentence that wastes zero words. The parenthetical clarifies the source-of-truth distinction efficiently. Every element 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?

As a read tool with no output schema and no annotations, the description provides reasonable context about what data is returned (structured message history). However, for a 2-param tool it doesn't explain the limit's role in result ordering or pagination, and with no output schema, some return-format expectations would help. Adequate for a simple fetch operation but leaves 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?

Schema description coverage is 0%, so the description must compensate. The description adds value by framing the data as 'structured message history' and establishing it as the source of truth, which helps the agent understand what the 'agent' parameter refers to. However, the description doesn't explain the 'limit' parameter semantics (ordering, truncation behavior) beyond what the schema constraints imply. With 0% coverage and 2 params, it partially compensates but leaves the limit behavior implicit.

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 ('Fetch'), resource ('an agent's structured message history'), and distinguishes it from the tmux pane as a live view. It identifies this as the source of truth, which differentiates it from sibling tools like tmux_send and tmux_broadcast. However, it doesn't reference sibling read tools specifically, so it's clear but not fully differentiated against the sibling set.

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 ('source of truth' vs 'tmux pane is just a live view'), which helps the agent know this is the canonical way to retrieve history. However, it doesn't explicitly state when to use this versus tmux_attach_info or tmux_list_agents, nor does it note any exclusions or alternatives. The context is implied rather than explicit.

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, but for a read-only list operation the description covers the core behavior adequately. It doesn't disclose whether this is read-only, whether it reflects live or cached state, ordering, or pagination, but a simple list operation has limited behavioral surface to disclose. Acceptable given the simple nature.

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?

One sentence, zero waste. Front-loaded with the verb 'List' confirming the scope. Exactly as concise as it should be for a simple no-parameter list 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?

For a zero-parameter listing tool with no output schema, the description is largely sufficient. No prerequisite setup, auth, or state dependencies are mentioned, which could matter in a mesh context, but the primary function is fully conveyed. Slight gap on return format but acceptable for an agent listing 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?

Tool has 0 parameters, so there is nothing to document beyond the description itself. Schema coverage is 100% trivially, and the description accurately conveys what the tool returns (registered agents in the mesh). Baseline 4 for a zero-parameter tool 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?

Clear verb+resource: 'List every agent registered in the mesh.' Distinguishes from siblings like register/send/broadcast which are mutation/communication tools. Could be slightly sharper about why it differs from tmux_attach_info, which likely also lists agents/attachments, but the verb+scope is 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?

No explicit when-to-use or alternatives guidance. The context signals show 0 parameters and sibling tools for discovery vs registration vs messaging. The description implies it's for discovering registered agents but doesn't state when to prefer it over tmux_attach_info or contrast with registration.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: the session becomes live (messages appear on screen), Claude responds automatically, no polling is needed, and no human input is required. It doesn't explicitly state safety side-effects (e.g., whether it affects existing panes or requires tmux running), but the core live-chat behavior is well 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 sentences, zero waste. First sentence states the core action; second explains the persistent behavior and its implications. Every sentence earns its place and it's front-loaded with the primary purpose.

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

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

The tool is simple (1 param, no output schema, no nested objects), so the description is largely sufficient. It connects the tool to the tmux agent workflow (live chatting vs polling), which is the key context. A minor gap: it doesn't clarify whether the agent parameter must reference a previously registered agent (via tmux_register_agent) — but given low complexity, this is a minor completeness miss rather than a critical one.

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 0% and there's just one parameter (agent) with no description. The description adds context that the agent names the identity under which the Claude session runs, and implies 'From then on, tmux_send to that agent' establishes agent as the key. For a single self-evident parameter (agent = what agent to spawn as), the description gives enough meaning, but it doesn't explicitly state what values are valid (e.g., must be a registered agent).

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 an interactive Claude Code session in a tmux pane as a given agent, with specific verb (spawn), resource (Claude Code session in tmux pane), and a clear distinction from siblings — it's the setup tool before using tmux_send, and it explicitly contrasts live typing (no polling) against the alternative. This is specific and distinguishes purpose well.

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

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

The description explains the follow-up workflow (tmux_send types directly into the chat afterward) and sets expectations around behavior (no polling, no human input). It doesn't explicitly state when NOT to use it or name alternatives for other scenarios, but the interaction with tmux_send is clear enough context for when this is needed.

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 reveals the side effect of creating a live tmux pane, which is helpful. However, it doesn't disclose whether re-registering an existing agent is idempotent, what happens if the pane already exists, whether registration has side effects beyond pane creation, or any error conditions. For a tool that mutates state, this is a meaningful 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 compact—two sentences—and front-loads the primary purpose before the usage caveat. Every sentence earns its place, and there's no wasted language. Minor deduction only because it could slightly clarify the parameter-relationship.

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 1-parameter tool with no output schema and no nested objects, the description addresses the core purpose and usage context. However, without annotations, it doesn't fully disclose behavioral subtlety (idempotency, existing-pane behavior), which is relevant for an agent deciding whether to call it. It's adequate but leaves behavioral edge cases unexplained.

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 0%, so the description must compensate for the single 'name' parameter. The description mentions 'agent' in the context of registration and implies the name identifies the agent, but it doesn't explicitly state that the 'name' parameter is the agent identifier. However, with only one parameter whose purpose is fairly self-evident from the tool name and required flag, the marginal value the description could add is limited.

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 'Register an agent and ensure its live tmux pane exists' which clearly identifies the verb (register) and resource (agent) with a specific outcome (pane creation). However, it doesn't fully differentiate it from siblings like tmux_send or tmux_broadcast; the differentiation is only implied via the note that they self-provision. It's reasonably clear but not explicitly distinguishing.

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

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

The description explicitly states when to use the tool: 'Not required before send/broadcast — they self-provision — but useful to pre-create a pane before anyone messages that agent.' This gives clear contextual guidance on when it's needed vs. unnecessary, and implicitly contrasts with the send/broadcast siblings. This exceeds basic usage 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 provided, the description carries the full burden. It does add meaningful behavioral context: messages appear instantly (push-based, no polling) and are 'recorded in queryable history' — which points to tmux_history's capability. However, it doesn't disclose any side effects, delivery failure behavior, whether the 'from' must be a registered agent, or what happens if the recipient isn't online. These gaps are notable for a messaging/side-effect tool with zero annotation coverage.

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, tight and efficient. Each sentence earns its place: the first states purpose and scope, the second adds behavioral details (push mechanism, persistence). No wasted words, properly framed for a single-sentence-per-concept structure.

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?

This is a state-changing tool (sends messages) with no annotations and no output schema, so the description must carry more weight. It does convey the core delivery semantics (instant, push-based) and persistence (history), which is decent. However, it omits required prerequisites (agent registration via tmux_register_agent), error cases, and confirmation behavior. For a 3-param side-effect tool with zero annotation coverage, this 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?

Schema description coverage is 0%, so the description must compensate. The description names 'recipient' (mapping to 'to') but provides no semantic detail for 'from' (is it an arbitrary label or must it match a registered agent?) or 'body' (format constraints, size limits). The description adds minimal parameter meaning beyond the generic property names in 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 ('Send a message to one agent') that clearly differentiates from siblings like tmux_broadcast (which sends to many). It identifies the target recipient and the push mechanism. However, it doesn't explicitly name the differentiating sibling alternative (tmux_broadcast) which would strengthen the purpose statement.

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 this is for one-to-one messaging ('to one agent') which distinguishes from broadcast, but it doesn't explicitly provide when-to-use/when-not-to-use guidance or name alternative tools. The push-based/polling distinction adds useful context about the delivery model but doesn't say when to prefer this over tmux_broadcast or tmux_history.

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