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

Without annotations, the description carries the full burden. It mentions that stop/terminate can save log/macros and fall back to ending a process this server started, but lacks details on side effects, permissions, or state changes (e.g., what happens if launch is called while already running).

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 relatively concise but could be more structured. It front-loads the purpose and lists operations, but the parameter explanation is embedded in a sentence about stop/terminate, making it less clear.

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 low parameter coverage, the description is incomplete. It lacks information on return values, error conditions, prerequisites (e.g., is fldigi must be installed?), and how to handle failed operations. The agent would struggle to use the tool correctly without additional 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?

The schema has 0% coverage, so the description must explain parameters. It names operations in text but does not enumerate the exact string values for the 'operation' parameter. 'save_log' and 'save_macros' are implied in the stop/terminate description but not explicitly tied to parameter names or behaviors.

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 manages the fldigi program and its process, listing specific info and process operations. However, it does not explicitly differentiate from sibling tools like controls or diagnostics, which might also interact with fldigi.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lists operations but does not specify scenarios or prerequisites, 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?

Given no annotations, the description carries the full burden. It discloses that the tool is experimental, region-aware, informational only, and that move_to_watering_hole sets the dial without transmitting. This covers key behavioral aspects adequately.

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, front-loading the purpose and then listing operations succinctly. Every sentence contributes necessary information without redundancy.

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

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

For a tool with 4 parameters and no output schema, the description covers the three operations and their parameters. It could be more complete by mentioning the return format, but overall it provides sufficient context for an informational 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?

Schema coverage is 0%, but the description explains each operation's parameters (e.g., lookup uses frequency_hz and optional mode, watering_hole uses mode and optional band). It adds meaning beyond parameter names, such as 'what the band plan says at a frequency' and 'preferred calling frequency'.

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 advisory band guidance for QSY help, listing three specific operations (lookup, watering_hole, move_to_watering_hole). It uses specific verbs and identifies the resource (band plan). However, it does not explicitly distinguish itself from sibling tools like frequency or rig.

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 mentions 'informational / QSY help only' and that move_to_watering_hole does not transmit, implying read-only use. It does not explicitly state when to use this tool versus alternatives or provide contraindications.

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, this description carries the full burden, and it excels: it discloses accumulation of text since last clear, newline semantics for lost-and-regained signals, the patch requirement, graceful fallback on stock fldigi, and receive-only safety. This is far beyond a basic capability statement.

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 information-dense and front-loaded with the core purpose, then operations, then compatibility. No word is wasted, though the waterfall/left-panel analogy is secondary; it earns its place by grounding the tool in the UI.

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 one-parameter tool with no output schema, the description covers the main return payload, behavior quirks, prerequisites, and error behavior. It is missing only minor details such as the exact response for clear/available, but the agent has enough 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 coverage is 0% and operation has no enum, so the description must supply meaning. It does: it enumerates channels, clear, and available operations and details the channels result shape and accumulation behavior. It leaves clear/available outcomes slightly underspecified, but the names plus context are enough for an agent to operate.

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 identifies the tool as fldigi's Signal Browser over XML-RPC and explains that it returns stations locked by the decoder bank with decoded text, plus the operations available. This is a clear function-resource pairing, but it does not explicitly contrast with sibling tools like signal_hunt or modem.

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 gives helpful context: suitable for PSK/RTTY/CW, needs a patched fldigi, is receive-only, and is meant for signals too weak for the waterfall. It implies when to use it, but it does not name alternative tools or state explicit when-not-to-use conditions beyond 'receive only'.

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

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

No annotations are provided, so the description must cover behavioral aspects. It mentions 'operations' implying both read and write capabilities (get/set/toggle), but does not describe side effects, idempotency, or safety implications (e.g., whether toggling AFC affects other settings).

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 dense paragraph. It front-loads the purpose and lists operations efficiently, but could benefit from structured formatting (e.g., bullet points) to improve readability. It is not overly long but feels cramped.

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, 2 parameters (one undocumented), and 14 sibling tools, the description is incomplete. It does not explain return values, error conditions, or the role of the 'value' parameter. The agent lacks critical context to use this tool effectively.

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

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

The schema has 0% description coverage, so the description must compensate. It enumerates valid values for 'operation' in a list, which adds meaning beyond the schema's empty description. However, it fails to describe the 'value' parameter at all, leaving its type and allowed values ambiguous.

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 domain: fldigi operating controls and status, and lists specific operations. It distinguishes the tool from general-purpose tools but does not differentiate from sibling tools that may also relate to fldigi, such as 'fldigi_call' or 'frequency'.

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 lists operations but provides no guidance on when to use this tool versus alternatives, nor when to use specific operations. Sibling tools are listed but not differentiated, leaving the agent to infer usage context without explicit direction.

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 it does not connect to fldigi, and details exactly what information it reports (resolved FLDIGI_HOST/PORT, Python version, hostname, transmit-gate state, network interfaces). No annotations provided, but description fully informs agent of behavior.

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

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

Concise multi-sentence paragraph that front-loads the main purpose and adds necessary context efficiently. Every sentence adds value without redundancy.

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

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

Given zero parameters and no output schema, the description fully explains the tool's purpose, what it reports, and how to interpret results. It is complete for a diagnostic 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?

No parameters exist, so baseline 4. The description adds no parameter info because none are needed.

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 it performs host and network diagnostics for troubleshooting connectivity. The description distinguishes itself from siblings by specifying its diagnostic scope, which is unique among the listed 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?

Explicitly states that it does NOT connect to fldigi, and provides guidance on what to do if a non-loopback host times out, directing to mcp-host-bridge docs. This helps the agent choose this tool for connectivity troubleshooting.

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

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

No annotations are provided, so the description must bear full burden. It mentions that keying methods are 'callsign-gated', but does not disclose other behavioral traits such as destructive potential, authentication requirements, or error behavior. This is moderately transparent.

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: three sentences with no redundant information. The first sentence front-loads the core purpose and an example, making it easy for an agent to quickly grasp the tool's 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?

Given the lack of an output schema and annotations, the description provides adequate context for understanding the tool's use and discovery. However, it does not describe return values or error handling, which would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate. It explains that 'method' is a dotted XML-RPC method name, adding meaning beyond the schema. However, it does not clarify the structure or purpose of 'params', leaving some 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 identifies the tool as an 'escape hatch' for calling any fldigi XML-RPC method by dotted name, with a concrete example ('rig.get_mode'). This distinguishes it from sibling tools, which are domain-specific.

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 advises using `station` with 'list_methods' to discover available methods, implying that this tool should be used when no specific sibling tool exists. However, it does not explicitly state when not to use it or provide 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?

With no annotations, the description carries the full behavioral disclosure burden. It does add some useful context: operations require a running flmsg and do not key the transmitter, and get_data is clarified as returning RX data since the last query. But the behaviors of online, available, transfer, and squelch are left completely unexplained.

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 short and front-loaded, with the operation list first and the safety-relevant caveat second. Every sentence contributes, though the opening phrase 'flmsg (message forms) interworking' is a bit awkward and could be phrased 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?

Given the absence of annotations, an output schema, and parameter descriptions, the tool definition is incomplete. It names operations but does not explain most of them, their expected effects, return values, or prerequisites beyond needing a running flmsg.

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 only defines an 'operation' string with no enum or descriptions, so the description's list of operations adds real value by enumerating likely accepted values. It even explains get_data, but the other operation names are not defined, so the agent still lacks enough semantic detail to choose confidently.

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 that the tool signals or hands data to a running flmsg, which is a clear enough action on a named resource. The operation list adds specificity, and the caveat that none of the operations key the transmitter helps separate it from transmit-focused siblings, though it does not name any sibling explicitly.

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 'signal or hand data to a running flmsg' implies when the tool is appropriate, and 'none of them key the transmitter' provides a useful exclusion. However, there is no explicit guidance about when to choose this tool over sibling tools or how to select among the listed operations.

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 full burden but only lists operations. It fails to disclose side effects (e.g., whether setting frequency affects other settings), permissions needed, or error behavior, providing minimal 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?

The description is concise, listing operations in a compact format. It avoids redundancy but could benefit from slight restructuring (e.g., separating frequency and sideband concerns) for clarity.

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

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

Given the tool has 2 parameters, multiple operations, and no output schema, the description is incomplete. It omits return values, success/failure indicators, and examples, leaving many usage questions unanswered.

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 description must compensate. It explains that 'value' is in Hz for set/increment operations and 'USB' or 'LSB' for set_sideband. However, it does not fully clarify the 'operation' parameter's enumerated values or provide format constraints.

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 handles RF frequency and waterfall sideband, listing specific operations (get, set, increment, get_sideband, set_sideband). This distinguishes it from sibling tools like rig or controls by focusing on frequency and sideband control.

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

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

No guidance is provided on when to use this tool vs alternatives, nor any conditions for when not to use it. The description simply lists operations without 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It names operations but does not explain side effects, whether enable_arq/enable_kiss change persistent state, prerequisites, or what in_use returns. The mutating nature of 'enable' is implied but not stated.

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 short and front-loaded with the resource type followed by the operation list. There is minor grammatical awkwardness, but every clause contributes useful information and there is no redundancy.

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

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

For a single-parameter tool, listing the expected operation values is the core requirementakey information. Still, with no annotations and no output schema, the description leaves out when to use each operation and what behavior or result follows, making the definition minimally viable rather than 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?

The schema only defines a required string 'operation' with no enum or description (0% coverage). The description compensates by listing the valid operation values and clarifying in_use as 'which port is active'. However, it does not explain the individual semantics or effects of enable_kiss and enable_arq beyond their names.

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 the resource as an 'ARQ / KISS I/O port' and enumerates the operations it supports: in_use, enable_kiss, enable_arq. This gives an agent a concrete sense of what the tool does, though it stops short of an explicit verb phrase. The I/O-port focus also distinguishes it from comms siblings like modem and 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?

There is no guidance on when to choose this tool over alternatives or what conditions call for KISS versus ARQ. The operation list implies usage for port control, but no exclusions or comparisons to sibling tools are provided. An agent must 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It mentions deprecation and the existence of current equivalents, but does not state whether operations are read-only or mutating, what side effects they have, how errors surface, or any operational constraints. This is insufficient for a tool that dispatches many different legacy methods.

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 and front-loaded with its core purpose: deprecated methods. The mapping list is dense but every mapping earns its place by pointing to the correct alternative tool. There is no filler or redundant repetition of schema 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?

Despite the useful mappings, the description is incomplete. It never explicitly states that the 'operation' parameter selects the legacy method, does not describe how to pass values, does not list return behavior, and lacks any guidance for invalid or unknown operation names. An agent would still need to infer how to construct a valid call.

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 does partially by listing valid operation names (get/set_sideband, rsid, etc.), which helps populate the 'operation' parameter. However, it does not explain the 'value' parameter at all, nor how it applies to set operations, so the description only partially compensates for the schema's lack of detail.

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 identifies the tool as a collection of deprecated fldigi methods and explains why it exists ('kept so the whole catalog is reachable'). It does not explicitly state a verb like 'invoke' or 'call', but the mapping list makes the resource and behavior recognizable and differentiates it from current equivalents.

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 says current equivalents should be preferred and then provides a direct mapping for each legacy method to its modern counterpart (e.g., 'rsid -> controls toggle_rxid'). This gives an agent precise guidance on when not to use this tool and which sibling to use instead.

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

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

With no annotations, the description carries the full burden and does disclose useful behavioral details: it lists the five operations, distinguishes settable from gettable fields, notes that contest_counter is set-only, and specifies that last_record/all_records return ADIF. It does not mention error handling, side effects, or persistence, but it covers the core behavioral surface of the 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?

The description is well-structured: the first sentence introduces the resource and lists operations, followed by two paragraphs grouping settable and gettable fields, and ends with return format. It is information-dense but not bloated. It could be slightly more compact by folding the field lists, but the structure aids comprehension.

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

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

Given the tool's complexity (multiple operations, many fields, no output schema), the description covers a lot but leaves gaps: it does not give exact syntax for calling operations (e.g., operation='get' with field='call'), does not state the return format for get or clear operations (only last_record/all_records mention ADIF), and does not explain behavior when setting a gettable-only field. These are important for correct invocation, so completeness is only partial.

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 does so by explaining the operation values (get, set, clear, last_record, all_records), enumerating valid field names, and clarifying that contest_counter is set-only. This gives the agent meaning for the 'operation', 'field', and 'value' parameters beyond the bare schema, even though it does not explicitly map each parameter to a formal description.

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 manages 'Logbook (QSO / contest) fields' and enumerates operations (get, set, clear, last_record, all_records) and field categories (settable vs gettable). It is specific about the resource and actions, making the purpose unambiguous. However, it does not explicitly differentiate from sibling tools like flmsg or fldigi_call that might also touch logging, so it misses a point for explicit sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any conditions or exclusions. It lists operations and fields but does not explain scenarios where log is preferred or not appropriate. The agent is left to infer usage from the tool name and field lists, which is insufficient given the many 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, the description must disclose behavioral traits on its own. It only lists operations like get/set/inc_carrier and search_up/down without explaining side effects, state changes, return values, or preconditions. The 'set (value=mode name)' example hints at mutation but leaves the behavior largely undisclosed.

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 and front-loaded with purpose, followed by a dense but readable list of operations and examples. It contains no filler, though the flat prose list could be structured more clearly as separate entries.

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 large number of operations, two opaque parameters, no annotations, and no output schema, the description is not complete enough for reliable invocation. It omits operation-specific semantics, return values, and required arguments beyond a couple of examples.

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 0% description coveragewing, but the description compensates partially by listing valid operation values and giving examples for 'value' (e.g., 'BPSK31', id). However, it does not define the expected type or requirement of 'value' for every operation, so the parameter semantics remain incomplete.

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 identifies the tool's domain: fldigi operating mode and modem settings, then enumerates the supported operations. It is specific enough to distinguish the modem tool from siblings like rig or frequency, though it does not explicitly compare itself to them.

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

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

No guidance is provided about when to use this tool instead of related sibling tools such as rig, controls, or frequency. The operation list implies possible sub-actions, but it does not describe situational selection criteria, prerequisites, or 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?

The description notes that send_message is 'callsign-gated', a useful behavioral trait. However, without annotations, it fails to disclose other important behaviors such as blocking behavior of get_message, potential side effects, or required 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 short but poorly structured: uses line breaks and inconsistent formatting (e.g., 'NAVTEX / SitorB mode' followed by a period, then a list). It could be more concise and better organized.

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, yet the description fails to cover essential details like return values, error handling, or prerequisites. For a tool with two operations and two parameters, this is severely incomplete.

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 coverage, the description compensates partially: it explains that for get_message 'value' is timeout seconds, and for send_message 'value' is text. However, it does not describe the 'operation' parameter's possible values or format beyond listing them in the text.

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 mentions NAVTEX/SitorB mode and lists two operations (get_message, send_message), giving a general sense of purpose. However, it lacks a clear verb+resource statement (e.g., 'Manage NAVTEX messages') and does not differentiate well from siblings like 'fldigi_call', 'modem', or 'text'.

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 vs alternatives (e.g., when to choose get_message vs send_message, or when to use another sibling). There are no explicit usage conditions or 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 must carry the behavioral burden. It discloses value formats and notes that set_smeter/set_pwrmeter drives fldigi's meter display, but it doesn't describe side effects of set operations, permissions, or failure behavior.

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

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

The description is front-loaded with the tool's purpose and backend, then presents a compact operation list. It is dense but not bloated, though the long run-on list could be slightly better structured.

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 two-parameter dispatch tool, the description covers most operation semantics and value formats, which is useful given the sparse schema. But with no output schema, it omits return/confirmation behavior for get operations and gives no error-handling guidance, so it isn't fully 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. It does explain value semantics for frequency, mode, bandwidths, qsy, and meter operations, which is essential. However, value types for some operations such as get/set_name, get_modes, and get/set_notch remain unspecified.

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 identifies the tool as CAT/rig control via flrig/Hamlib/RigCAT and enumerates a concrete set of operations, so an agent can infer what resource it acts on. It doesn't explicitly contrast itself with siblings like 'frequency' or 'controls', 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 phrase 'Rig (CAT) control' plus the operation list gives clear context for when the tool is relevant. However, it never states when not to use it or names alternatives among the sibling tools, leaving some routing decisions to inference.

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 burden. It discloses the patch requirement, states 'Receive only,' and explains that on stock 4.2.13 it says so instead of failing. However, it does not describe side effects of the 'clear' operation or detail the return format for all operations (e.g., 'available'), leaving some behavioral ambiguity.

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 paragraph that front-loads the main purpose, then provides operational details and prerequisites. It is concise and well-structured, with no redundant sentences, and each sentence 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?

The tool has one parameter, no output schema, and no annotations, so the description must carry the load. It covers purpose, operations, prerequisites, and stock behavior, and even specifies the output format for hits as {utc, mode, hz}. However, it does not fully describe return values for all operations (e.g., 'available') or the exact effect of 'clear', making it adequate but not exhaustive.

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 one 'operation' parameter with 0% description coverage. The description lists the possible values (hits, clear, available), which adds meaning beyond the schema. However, it does not elaborate on what each operation does or its expected behavior, so the semantics are only partially defined.

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 reports RSID bursts as {utc, mode, hz} entries since the last clear, and lists the operations (hits, clear, available). It distinguishes the tool's role in monitoring passband modes without switching the modem, giving it a specific purpose. However, it does not explicitly differentiate from a sibling tool, so it's clear but not fully differentiated.

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 when to use it: when fldigi's RSID is in notify-only mode, so the current modem keeps decoding. It also mentions the patch prerequisite and the behavior on stock. However, it does not reference alternative tools or provide explicit 'use this instead of X' guidance, leaving the decision partially to the agent.

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

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

With no annotations, the description carries the full burden, and it is transparent: 'Nothing here transmits', browser only reports what fldigi is set to and names no mode, api is slow, and each candidate's fields are enumerated. This gives an agent accurate expectations without needing 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 long but dense and front-loaded with the core purpose. Each method and output field earns its place, though the prose-heavy format could be slightly more scannable with bullets or explicit parameter labels.

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 and no output schema, the description is remarkably complete: it covers all modes of operation, return-value shape, dependencies, and behavioral caveats. Missing details are limited to the top parameter and some error/edge-case behavior, which prevents a perfect score.

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 method, device, seconds, wav, and partially mode via the api example, but never defines the top parameter or clarifies how mode behaves for the audio and browser methods. This is a minor gap in an otherwise strong explanation.

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 opens with a specific verb and resource: 'Find and name the signals in the receiver audio and rank them...'. It also clarifies the ranking rationale with the contest-operator waterfall analogyтные and distinguishes methods so an agent can infer what the tool does relative to siblings like browser and tune_to.

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?

Each method is given an explicit context: audio is the default, devices lists input devices, browser is for near-floor stations that the spectrum analyser misses, and api is a blind fallback with no audio access. It also states prerequisites such as the optional 'hunt' package and the browser patch, and notes that api is slow.

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, and the description does not disclose any behavioral traits such as whether operations are destructive, require authentication, or have side effects. The listed operations suggest configuration and reporting, but this is inferred rather than stated.

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 and to the point, but it is not well-structured. It uses periods and line breaks in a way that could be clearer. It is concise but lacks organization.

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 is incomplete. It does not explain what each operation does, what the return values are, or any potential side effects. The tool's complexity (multiple operations) demands more detail.

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

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

The description adds some meaning to the parameters by indicating that 'value' is a bool for 'set_auto'. However, it does not explain the 'value' parameter for other operations, and the schema coverage is 0%, so the description only partially compensates for the lack of schema 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 mentions 'Spotting / PSK Reporter' and lists operations, giving a general idea of the tool's domain. However, it lacks a clear verb-resource statement and does not fully explain what 'spotting' entails, leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus sibling tools like 'frequency' or 'log'. The description does not state any prerequisites or context, leaving the agent without decision support.

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. The description does not disclose side effects, permissions, or whether the tool is read-only. It only describes the output snapshot without behavioral context.

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 short sentence that conveys the tool's output efficiently. No unnecessary words or repetition. Perfectly concise.

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 lists output fields but lacks types or value ranges. It provides a reasonable idea of what the tool returns but could be more detailed for an unparameterized 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?

There are zero parameters, so the input schema fully defines all parameters. The description adds no parameter info because none is needed. Baseline 4 for 0-parameter tools is appropriate.

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

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

The description clearly states it provides a 'Snapshot' of specific status fields (version, modem, frequency, TX/RX state, etc.), making the purpose evident. It distinguishes itself from sibling tools like 'frequency' or 'modem' by being a composite view, though not explicitly.

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. No mention of prerequisites, context, or when not to use it. The description only lists output fields.

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 discloses that add_tx/add_tx_bytes only stage text and do not transmit, which is a non-obvious behavior. However, with no annotations, the description carries the full burden and it does not mention side effects of clear operations, return values, or permissions, so it's only partially transparent.

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 paragraph with a list of operations. It's concise but not well-structured; it dumps a list without grouping or front-loading the most critical information. It's adequate but could be more readable.

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 4 parameters, no annotations, and no output schema. The description lists operations but lacks details on return values, error conditions, and the context (e.g., which modem it applies to). It also doesn't explain the difference between get_rxtx_data, get_rx_data, get_tx_data. This is incomplete for an agent to use 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?

The schema has no descriptions, so the description must explain parameters. It does explain start, length, and value in the context of operations (e.g., read uses start/length, get_rx uses value as [start, length]). However, not all parameters are fully described (e.g., operation has no enum, but the list of operations gives meaning). Some operations like add_tx_queue are not explained in terms of parameters.

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 it handles RX/TX text and data and lists specific operations (read, rx_length, get_rx, etc.), making the resource and actions clear. However, it does not explicitly distinguish itself from sibling tools like transmit or modem, so it doesn't earn 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?

No guidance on when to use this tool versus alternatives. It doesn't mention any exclusions or comparisons to other tools. The only usage note is that add_tx stages text without transmitting, which is a behavioral detail but not a usage guideline for tool 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 provided, the description carries the full behavioral burden, and it discloses meaningful behavior: keying vs. non-keying operations, callsign requirements, that rx/abort/timing operations are always allowed, and that send auto-returns to receive. This goes well beyond a basic statement of function, though it still omits details like error behavior or state changes from abort/disable_tx.

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 dense but every sentence earns its place: an overview, an operations list, a keying-behavior note, and the send auto-return default. It is front-loaded with 'Transmitter control' and the operation list, with no filler or repetition.

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 complex with many operations, four parameters, no annotations, and no output schema, so the description must cover a lot. It covers operation semantics, timing return formats, keying restrictions, and the send default, but leaves unclear the full set of operation-specific value formats, especially for tune, and does not describe response/error behavior. It is adequate but has clear 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 compensates by explaining the operation string valuesgcd, including run_macro's value as an id, tx_timing's value as a test string, char_timing's value as a single character, and send's text parameter. It does not fully explain the value parameter for tune or all possible operation values, but it adds substantial meaning beyond the bare schema.

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

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

The description clearly states the tool is 'Transmitter control' and enumerates specific operations (tx, tune, rx, abort, etc.), making the resource and available actions explicit. It does not explicitly differentiate from sibling tools like fldigi_call or tune_to, but the operation list and transmitter focus give sufficient clarity.

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 internal guidance about which operations key the transmitter and callsign requirements, but it does not state when to use this tool versus sibling alternatives such as rig, modem, tune_to, or fldigi_call. There is no explicit 'use this for X, use that for Y' routing, leaving tool-selection guidance mostly absent.

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 full behavioral burden. It discloses that AFC is on and RxID is off by default, explains why RxID is off (to prevent retuning), and explicitly states it does not transmit. This provides a clear safety profile and operational behavior, though it doesn't mention any other side effects or requirements.

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 somewhat long but every sentence adds value. It front-loads the purpose, then details settings, then provides follow-up verification steps. The structure is logical and efficient, though it could be slightly more concise without losing 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 tuning tool with no output schema and no annotations, the description is fairly complete. It covers what it does, parameter details, behavioral defaults, and how to verify success. It doesn't mention error conditions or prerequisites, but for this type of tool it is adequate.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It does: fldigi_modem with examples, carrier_hz as 'audio carrier', afc default on, rxid default off, and the rationale for rxid. This adds meaning far beyond the schema, which has no parameter 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 clearly states the tool's action: 'Set fldigi to a signal_hunt candidate' and specifies the key settings (modem, carrier, AFC, RxID). It includes concrete examples of modem names and explicitly states 'Does not transmit,' distinguishing it from transmit tools. The purpose is specific and unambiguous.

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

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

The description provides clear context: it is for signal_hunt candidates and it tells the user to read the result via 'text' and check lock via 'modem get_quality.' It implies when to use it (when tuning to a candidate) but doesn't explicitly mention alternatives or when not to use it beyond 'Does not transmit.' However, the follow-up steps are helpful for correct 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that send_file transmits and is callsign-gated, which is useful, but it does not disclose the behavior of other operations, side effects, state changes, or what happens during reception/transmission. The description is a terse list of operation names without behavioral context.

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 and front-loads the mode name, but the operation list is dense and lacks formatting that would aid scanning. The final sentence about send_file is useful but could be integrated with the operation list. It is not overly verbose, but it sacrifices clarity for brevity.

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 2 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the return values, error conditions, or the behavior of each operation. The callsign-gating note for send_file is a good start, but many operations (e.g., skip_apt, skip_phasing, tx_abort) are left entirely unexplained, making it hard for an agent to know when and how to invoke them.

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 lack of parameter documentation. The description lists operation names and some value types (bool, int, timeout, [filename, timeout_seconds]), but it does not explain the meaning of the 'value' parameter in general, nor does it document the 'operation' parameter beyond listing possible values. The value types are helpful but incomplete.

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 WEFAX as a weather fax mode and enumerates its operations, which gives a clear sense of the tool's purpose. However, it does not explicitly state what the tool does in a single verb+resource form, and the operation list is presented as a flat enumeration without explaining what each operation accomplishes.

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 by listing operations, and it notes that send_file is callsign-gated, which is a usage constraint. However, it does not provide guidance on when to use this tool versus alternatives like navtex or fldigi_call, nor does it explain which operation to choose in a given context.

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