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

No annotations are provided, so the description carries the burden. It discloses that the tool is non-transmitting and explains the effect of sort_order values, but lacks details on side effects, reversibility, or permissions.

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 with three short sentences, no fluff, and front-loads the core purpose immediately.

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 niche tool with no output schema and three parameters, it covers the main functionality and special values but omits the 'instance' parameter and any return value details, leaving some 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%. The description adds clear meaning for 'sort_order' but does not explain 'instance', leaving one parameter undocumented. 'dx_call' is self-explanatory from the name.

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 'Set' and the resource 'Fox/Hound sort-order annotation for a DX call', and distinguishes it from siblings like 'clear' or 'transmit' by specifying it does not transmit.

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?

It explains the niche use case (server scoring callers for sorting Hound queue) and provides guidance on sort_order values, but does not explicitly contrast with alternatives or state when not to use.

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 must carry the burden. It only mentions 'no transmit', but fails to disclose other behavioral traits (e.g., whether it is destructive, if it requires an active session, or what happens to existing decodes).

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 very short (two lines plus parameter list) and front-loaded with the main purpose. Every sentence adds value, but the structure could be slightly improved by separating the parameter details more clearly.

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 tool with no output schema and two parameters, the description covers the main action and one parameter well. However, it lacks details on side effects, reversibility, or interaction with other windows, making it just 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?

With 0% schema description coverage, the description adds meaning for the 'window' parameter (band, rx, both) and default. However, the 'instance' parameter is left unexplained, which is a gap for a 2-parameter tool.

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 ('Clear') and resource ('WSJT-X decode window'), and adds a clarifying note about no transmit. It distinguishes from siblings like 'transmit' and 'reply', but could be more specific about what clearing entails.

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 on when to use this tool versus alternatives like 'free_text' or 'highlight'. No exclusions or context provided, leaving the agent to infer usage.

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?

Discloses important behavioral details beyond the schema, such as 'no transmit', no dial-frequency control, and the mandatory sending of boolean parameters. With no annotations, this is valuable transparency.

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

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

Well-structured with a summary sentence, parameter list, and bullet-point caveats. Slightly verbose but efficient for the complexity.

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 10 optional parameters, no output schema, and no annotations, the description provides sufficient context about what the tool does, its caveats, and parameter behavior. Lacks mention of the instance parameter and any return value, but overall 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?

Description lists most parameters and explains the 'no change' semantics for empty string and None. However, it omits the 'instance' parameter entirely, and schema coverage is 0%, so the description does not fully compensate.

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 it sets operating parameters via a 'Configure' message and explicitly lists which parameters it controls. It distinguishes from sibling tools like 'transmit' by noting 'no transmit'.

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?

Includes explicit caveats about when not to use (no dial-frequency control) and how boolean parameters behave. Does not explicitly name alternative tools but provides clear context for appropriate use.

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 provided, but the description fully discloses behavior: read returns most recent N, drain advances cursor (each decode returned once), clear_local does not touch WSJT-X, replay re-broadcasts with New=false. All behaviors are clearly explained.

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: summary line, operations section, decode fields. It is front-loaded with essential info. Slightly verbose but every sentence 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 the tool has 2 params, no output schema, and no annotations, the description thoroughly covers all operations, decode fields, and even mentions the `seq` field for use with the 'reply' tool. Complete for agent 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 0%, so description compensates. It explains the 'limit' parameter (default 50, most recent N) and implicitly maps operations to values (read, drain, clear_local, replay) from the description. Explicit naming of operation values would improve clarity.

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 RX data plane decodes, listing specific operations (read, drain, clear_local, replay) and what each decode carries. This distinguishes it from sibling tools like 'status' or 'log'.

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

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

The description gives explicit usage for each operation: read for recent N, drain for polling, clear_local to empty buffer, replay for backfill on connect. It mentions safety of replay. However, it doesn't explicitly say when NOT to use this tool or compare to alternatives.

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 significant behavioral context beyond the readOnlyHint annotation: it explains the tool reports specific diagnostic data (host/port, listener status, datagram counts, etc.) and highlights potential issues like sandboxing or port conflicts. 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?

Two sentences: first sentence states purpose; second provides detailed scope and context. No wasted words, front-loaded with key 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?

For a zero-parameter, no-output-schema tool, the description comprehensively lists what will be reported (host, port, listener, datagrams, instances, transmit-gate, network interfaces) and provides diagnostic context (potential conflicts). This is complete for troubleshooting connectivity.

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 no parameters (schema coverage 100%), the description correctly omits parameter details. The baseline for zero params is 4, and the description does not need to add param info.

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 provides 'Host + network + listener diagnostics for troubleshooting connectivity,' which is a specific verb (diagnostics) and resource (connectivity). It distinguishes itself from sibling tools like 'transmit' or 'reply' by being diagnostic rather than command-oriented.

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 what the tool does NOT do ('Does NOT command WSJT-X'), and outlines what it reports. While it doesn't directly say 'use this when you need to check connectivity,' the context of troubleshooting is implied, providing clear guidance on its non-command nature.

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 fully discloses safety (send=false always allowed), gating (requires WSJTX_CALLSIGN for send=true), and the fact that transmitting keys the radio. Also explains edge cases for empty text. Missing details like rate limits or side effects, but sufficiently transparent for typical use.

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?

Concise overall, with two clear parts: general description and detailed behavior. The sentence about empty text is slightly dense but still understandable. No redundant 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 no output schema and no annotations, the description covers the tool's purpose, usage scenarios, safety, and parameter behavior adequately. It explains edge cases and prerequisites. Omission of 'instance' parameter is the only gap.

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?

Describes semantics for 'send' and 'text' in detail, explaining their interaction and defaults. However, the 'instance' parameter is not mentioned at all, leaving its purpose unclear despite 0% schema 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?

Clearly states 'Set the free-text (Tx5) message' with a specific verb and resource, and distinguishes between safe text setting and initiating transmission (send=true). Differentiates from sibling tools like 'transmit' and 'wsjtx_call' by specifying the gated TX initiation.

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?

Explicitly describes when to use send=false (safe) vs send=true (requires WSJTX_CALLSIGN). Explains behavior for empty text in both modes. However, does not explicitly mention when not to use or alternatives to other 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?

No annotations are provided, so the description carries full burden. It discloses that 'clear' sends an invalid colour, 'clear_all' cancels all highlights, and notes a performance cap of ~100 highlights to avoid impacting decoding. This goes beyond what annotations would typically provide.

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 with bullet points for operations. It is concise but includes essential details like color formats and performance caution. Slightly longer than minimal, but every sentence 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 the tool has 6 parameters (0% schema coverage) and no output schema, the description covers all necessary behavioral and parameter information. It explains three operations, color formats, and a performance constraint, making it complete for the tool's complexity.

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 add meaning. It explains parameters for 'set' (callsign, background, foreground, highlight_last) and color formats (name, hex, RGB). For 'clear' it mentions callsign, and for 'clear_all' no params. It does not explain the 'instance' parameter, which is a minor 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 tool colours or clears a callsign in the Band Activity panel with no transmit. It distinguishes itself from sibling tools by specifying the UI panel and clarifying it does not transmit, which is important given siblings like 'transmit' and 'wsjtx_call'.

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 for each operation (set, clear, clear_all) and acceptable color formats. It includes a performance caution about keeping highlights modest. However, it does not explicitly discuss when not to use this tool versus alternatives among siblings.

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 that the tool does not transmit and only affects the session, which are key behavioral traits. It does not detail error handling or permissions, but for a simple override, 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?

The description is concise with three sentences, each adding value. It front-loads the purpose and avoids redundancy. No unnecessary details.

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 simple tool with two parameters and no output schema, the description covers purpose, behavior, and usage context. It lacks explanation of the 'instance' parameter and does not specify return values or error conditions, but overall it is sufficient.

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 no descriptions (0% coverage). The description partially compensates by explaining the 'grid' parameter format ('4- or 6-character'). However, the 'instance' parameter is not described, leaving ambiguity.

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 overrides the session Maidenhead grid, with specific verb ('Override') and resource ('session Maidenhead grid'). It also distinguishes from siblings by noting 'No transmit', which differentiates it from the transmit tool.

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 specifies when to use ('Intended for mobile/portable operation where the grid changes during a session') and implies when not to use ('Session-lifetime only — does not change the persistent setting'). However, it does not explicitly mention alternative tools for persistent changes, such as 'configure'.

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 indicate readOnlyHint=true. Description adds context (WSJT-X emission, pairing, forwarding purpose) but does not disclose other behavioral traits like rate limits or response format. 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?

Description is concise with two sentences and a note, front-loading the core purpose without redundancy. Every sentence 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 one optional parameter, no output schema, and supportive annotations, the description covers source, data structure, and intended use. Lacks explanation of parameter meaning, but otherwise 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?

The single 'limit' parameter is not explained in the description despite 0% schema coverage. Its purpose and default behavior are left ambiguous, requiring the agent to infer.

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?

Description clearly states 'Read buffered completed QSOs' with a specific resource and verb. It distinguishes itself by noting the paired data (QSOLogged and LoggedADIF) and the observe-only nature, separating it 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?

No explicit guidance on when to use this tool versus alternatives. The description implies it's for retrieving logged QSOs but does not define scenarios or exclude other tools like decodes or status.

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 fully carries the burden of disclosing behavioral traits. It explains that the tool only acts if the message exactly matches a prior CQ or QRZ decode, describes the Auto Seq behavior (sequences QSO or starts first transmission), and notes that Auto Seq is a UI setting. This is comprehensive.

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 yet complete, using bold for key terms and bullet-like structure. Every sentence adds value: first sentence states purpose, second clarifies equivalence, third explains Auto Seq, fourth details parameter usage. No redundant or fluff content.

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 (4 parameters, no output schema, 0% schema coverage), the description covers all necessary aspects: purpose, triggering conditions, parameter usage, and behavioral nuances (Auto Seq, modifiers). It references a sibling tool ('decodes') and explains the context of buffered decodes. No major 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?

Despite 0% schema description coverage, the description compensates well for most parameters. It explains 'seq' and 'message' in detail (identify from decodes, matching logic) and 'modifiers' (values like shift, ctrl, alt). The 'instance' parameter is not mentioned, leaving a small gap. Overall adds significant meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Answer a buffered decode — initiates a transmission (gated by callsign).' It uses a specific verb ('answer') and resource ('buffered decode'), and distinguishes itself from siblings like 'free_text' and 'transmit' by specifying it's equivalent to double-clicking a CQ/QRZ decode.

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 on when to use the tool: when you have a decode from the 'decodes' tool and want to reply. It explains how to identify the decode (by seq or message) and mentions modifiers. However, it lacks explicit exclusions or references to alternative tools for different use cases (e.g., sending arbitrary text with 'free_text').

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 mark readOnlyHint=true, and the description confirms read-only behavior. It details the returned data including special fields and error handling, adding value beyond 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?

Description is front-loaded with the main purpose and then provides details. It is appropriately sized but contains slightly more detail than necessary, yet not overly verbose.

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, the description fully explains return values and includes guidance for missing data. It covers all necessary context for the agent 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?

No parameters, so schema is irrelevant. The description adds full meaning about what the tool returns, which is rich and covers all necessary 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 clearly states the tool returns the latest WSJT-X state snapshot plus listener/connection health. It lists specific fields (dial frequency, mode, etc.) and distinguishes itself from siblings like decodes or diagnostics.

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 when to use (to get status) and what to do if no Status has arrived (ensure UDP server is pointed). It implies usage for overall state, though lacks explicit exclusions or comparisons to siblings.

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 full burden. It discloses that the tool does not cause transmission but does not mention error handling for missing configurations, effects on current operation, or any side effects. Minimal behavioral disclosure.

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

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

Two sentences with no wasted words. The action verb 'Switch' is the first word, and all information is front-loaded.

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

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

Given the tool has two parameters, no output schema, and no annotations, the description is too brief. It lacks details on return values, behavior when the configuration is missing, and what 'no transmit' means in the broader context of WSJT-X operation.

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 explains the 'name' parameter as the named configuration, but does not mention the optional 'instance' parameter or its purpose. Partial 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 uses a specific verb ('Switch') and resource ('WSJT-X to a named configuration') and explicitly states that the configuration must already exist, distinguishing it from sibling tools like 'configure' which likely creates or edits configurations. The 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?

The description implies when to use the tool (to switch to an existing configuration) and includes a behavioral note ('No transmit') but does not explicitly state when not to use it or provide direct alternatives among siblings.

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 full burden. It discloses that the UDP protocol can halt but not enable Tx, and explains the two operation behaviors. However, it does not mention any required permissions or side effects beyond taking off the air.

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 with a core statement followed by bullet points. Every sentence adds value, and it is front-loaded with the primary function.

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

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

The description adequately covers the tool's purpose and operations given its low complexity (2 params, no output schema). However, it fails to explain the 'instance' parameter, which may be important for context, leaving a completeness gap.

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 description must compensate. It explains the 'operation' parameter with two values and their effects, but does not explain the 'instance' parameter at all. Partial coverage leaves a 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 tool stops transmission, specifying two operations. It distinguishes from sibling tools 'reply' and 'free_text' which start transmission. However, the tool name 'transmit' may mislead, but the description clarifies the actual purpose.

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?

Explicitly states when to use this tool (to stop transmission) and when to use alternatives ('reply' or 'free_text' to start). Also notes that halting is always allowed, providing clear 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?

Discloses that keying messages are refused unless WSJT_CALLSIGN is set. Lists allowed message types. No annotations provided, so description carries full burden; mentions mutation (build and send) but lacks details on error behaviors.

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

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

Three efficient sentences plus an example; each sentence adds value, front-loaded with purpose. 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 no annotations or output schema, the description provides reasonable guidance but lacks details on return values, errors, and the 'instance' parameter. Adequate but not complete for a 3-param 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?

Explains 'message' and 'fields' parameters with examples and allowed values. However, 'instance' parameter is not described. Schema coverage is 0%, so description compensates partially but not fully.

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?

Clearly states 'Escape hatch: build and send any WSJT-X message type by name.' Lists allowed message types, distinguishing it from sibling specific tools like clear, configure, etc.

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?

Labels itself as 'escape hatch' implying use when no specific tool exists. Provides examples and notes a transmit gate condition, but doesn't explicitly state when not to use or alternatives.

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