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

With no annotations, the description carries the full burden. It usefully discloses two behavioral traits: it opens the mode if not already open (a side effect) and re-reads results after changes, plus the blank-argument-is-no-op rule. It does not state permissions, undo/reversibility, or failure behavior on invalid values, and defers return detail to the output schema.

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

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

A single well-formed sentence front-loads the primary action (open the mode and set parameters), with the partial-update rule appended. Every clause earns its place; 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?

For an 8-parameter, all-optional device-configuration tool with an output schema, the description covers the essentials (partial updates, mode auto-open, read-back). Still, it omits what an agent would want for a hardware config tool with no annotations: permission requirements, behavior on invalid ranges, and whether changes are atomic.

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 100%, so every parameter is documented in the schema itself (including value formats like '1GHz', enum-like mod lists, and the filter greyed-out caveat). The description only summarizes the parameter groups and adds nothing beyond the schema, so the 3 baseline applies.

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

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

The description states a specific verb ('set') and resource (SAStudio4's Digital Demod mode configuration), naming the settings it controls (modulation, symbol rate, center, filter, averaging, reference level). This distinguishes it from the sa_* spectrum-analyzer family by resource, though it never explicitly contrasts with sa_configure. An agent can identify the operation but must infer the sibling split from the 'Digital Demod' phrasing alone.

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?

Usage context is implied rather than stated: it is for configuring Digital Demod mode settings, and it usefully notes blank arguments are left unchanged (partial-update semantics). However, there is no explicit when-to-use vs sa_configure/dd_results guidance and no exclusions, leaving the agent to infer routing.

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. It usefully discloses side effects — files are written (CSV and PNG) and an image is returned — which is real value. It omits prerequisites (active Digital Demod measurement?), overwrite behavior, file destinations, and failure modes, so it is only partially transparent for a multi-side-effect operation.

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

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

A single front-loaded sentence that enumerates read-act, persistence, and return value in the order they matter. Zero padding.

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 six-parameter tool with no annotations and no output schema, the description covers the core flow adequately but leaves gaps: measurement preconditions, where files land, and how add_to_report ties into the report_* tools. Adequate but not complete.

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

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

Schema coverage is 50%; the schema already explains eye, label, and max_eye_traces (including the ~0.1 s per-trace cost). The description corroborates eye traces and the returned plot but says nothing about note, add_to_report, or how it interacts with the report_* sibling tools, so it does not compensate for the uncovered half.

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

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

States a specific verb+resource chain: read constellation points (plus ideal references and eye traces) from the Digital Demod screen, save CSV and PNG, and return the plot. That is unambiguous about what it produces. It never names or distinguishes itself from the closest sibling, dd_results, so it falls 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?

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. An agent must infer from the resource name alone that a Digital Demod measurement must be active and that this is preferred over a generic results reader for constellation data.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses what the returned numbers are and what they mean per modulation type, and implies a read-only measurement, but says nothing about permissions, timing constraints, or side effects. The absence of annotations leaves a real gap.

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

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

Front-loaded with the core purpose, then a compact per-modulation metric listing, then a single usage tip. Dense but each clause earns its place; the metric enumeration is long but informative.

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?

An output schema exists, so return values needn't be explained, and the description goes further by naming the metrics. However, with no annotations and three undocumented parameters (note, label, add_to_report), an agent still lacks guidance on side effects and reporting behavior.

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 50%; repeat, interval_s, and include_bits are documented in the schema. The description adds only marginal meaning to repeat ('stable figure') and says nothing about note, label, or add_to_report. Baseline 3 is appropriate at this coverage level.

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

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

States a specific verb and resource: it returns digital demod measurement results as numbers, and enumerates the exact metric set per modulation family (PSK/QAM, FSK/GMSK, ASK). An agent can distinguish it from dd_constellation (visual) and dd_configure without opening a schema, though no sibling is named 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 only usage direction is 'Use repeat > 1 for a stable figure,' which is a parameter tip rather than when-to-use guidance. It implies you read results after configuring the demod, but there are no exclusions or named 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 burden. It does not say whether the note is appended or inserted, where it lands relative to existing sections, whether the target report must be open/active, or that this is a write operation that mutates report state.

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

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

A single front-loaded sentence with no filler, which is appropriate sizing. It is terse rather than padded, though the brevity leaves the gaps noted in other dimensions.

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?

An output schema exists, so return values need no explanation, but for a mutation tool with zero annotations and two undocumented parameters it should at least cover prerequisites and the effect of the call. The description leaves those entirely open.

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 only 33%: 'text' (the required field) and 'heading' are undocumented in the schema. The description implies free text for 'text' and hints at heading-style labels with 'setup, observation, conclusion', but never ties these to the actual parameter names, so it only partially compensates.

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

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

States a specific verb ('Add') and resource ('free-text section ... to the report'), and the parenthetical names plausible section types. It does not differentiate itself from the nearby report_edit_item, so an agent cannot tell from the description alone which one to reach for.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. The presence of report_start/report_open siblings implies a report must exist first, but the description never says so.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutating tool. It does not say whether delete is irreversible, whether it overrides the other fields when combined, whether omitted/null fields are left unchanged or cleared, or what permissions are needed.

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

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

A single short sentence that front-loads the edit operation and appends the delete case. No filler, though the terseness borders on under-specification for a six-parameter mutation tool.

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?

An output schema exists, so return values need not be explained. However, for a tool that can destroy a report item with no annotations and only 50% schema coverage, the description omits critical interaction rules (delete vs. edit precedence, unchanged-field behavior), leaving the agent under-informed.

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 50%: index, limit and result are self-documented in the schema, while label, note and delete have no descriptions. The description adds the field-to-parameter mapping but does not clarify semantics like using '' to clear a result or null meaning 'no change', so it neither compensates fully nor is empty.

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

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

States a specific verb ('Edit') plus the resource ('report item') and enumerates the editable fields (label/note/result/limit), while also disclosing the delete capability. An agent can distinguish this from report_add_note or report_set_info, though the description never names those siblings 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?

There is no when-to-use guidance and no mention of alternatives such as report_set_info or report_add_note. The only contextual hook, that 'index' comes from report_status, lives in the schema rather than the description, so routing is left entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a side-effecting write (documents are produced) but says nothing about where files are written, whether existing exports are overwritten, whether an active report is required, or any auth/permission needs.

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

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

A single, front-loaded sentence with the verb and resource first and no filler. The trailing phrase 'from the active session' is vague, but no words are wasted.

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?

An output schema exists, so return values need not be explained, and there is only one well-documented parameter. Still, for a side-effecting export tool with zero annotation coverage, the description should mention the output destination/overwrite behavior and the prerequisite session state.

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 100% and the single 'fmt' parameter already documents its html|docx|both values. The description's plural 'document(s)' faintly hints that multiple formats can be produced, but adds no real meaning beyond the schema; baseline 3 applies.

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

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

States a specific verb ('Generate') and resource ('report document(s)'), so the agent knows this produces output artifacts rather than editing or reading report state. However, it offers no differentiation from siblings like report_start or report_open, which could plausibly also be described as 'generating' a report.

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?

'from the active session' implies a precondition (a session must already exist and hold report content), which is a weak usage signal. There is no explicit when-to-use vs. report_start/report_open/report_status guidance and no stated 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?

No annotations are provided, so the description carries the full behavioral burden. It never states that this is a non-destructive read, whether it is paginated, whether it covers all folders or a scoped subset, or whether it requires an active session — all meaningful gaps for a tool with zero annotation coverage.

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

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

A single four-word sentence with no filler and the resource front-loaded. It is efficient, though the extreme brevity is arguably under-specification rather than disciplined conciseness.

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?

An output schema exists, so return values need no explanation, and the zero-parameter schema is trivially complete. What remains missing is scope and session context for a list operation among many report_* siblings, leaving the definition only minimally 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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The empty schema is fully consistent with the 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?

States a concrete verb+resource ('List report folders'), which is enough for an agent to know it is a read-only enumeration tool. However, it does not differentiate itself from the many other report_* siblings (report_status, report_open, report_export), so the scope relative to alternatives is not made explicit.

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 when-to-use guidance is given. The description does not say when an agent should list report folders versus calling report_status, report_open, or report_export, nor does it mention prerequisites or ordering.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the action. It does not say what happens if the folder does not exist, whether the session must already be live, what state is restored, or whether resuming interferes with an already-open session.

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

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

A single short sentence that is front-loaded with the action. It is efficient, though its brevity tips into under-specification rather than maximal conciseness.

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 only one parameter, full schema coverage, and an output schema that covers return values, the definition is adequate but thin for a session-state operation with zero annotation coverage. A note on preconditions or interaction with existing sessions would complete it.

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 100% and the folder parameter is documented in the schema as an existing folder name or path, so the description need not repeat it. The description adds nothing beyond the schema, which is the expected baseline here.

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 verb 'resume' plus the resource 'report session' gives a specific, unambiguous action that an agent can distinguish from report_start's create-new semantics. It does not explicitly name the sibling it differs from, so it stops short of 5.

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

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

The word 'existing' implies this is for reconnecting to a prior session rather than creating one, which implicitly routes away from report_start, but there is no explicit when-to-use/when-not statement or reference to report_list/report_status for discovery.

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

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

With no annotations, the description carries the full behavioral burden, yet it only implies mutation via 'Update'. Critically, every parameter defaults to null and the description never says whether null means 'leave unchanged' or 'clear the field' — a decisive ambiguity for a mutation 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?

A single short sentence with no waste, but it is terse to the point of under-specification rather than efficient — the brevity removes needed information rather than improving navigability.

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?

An output schema exists, so return values need not be explained, but for a 7-parameter mutation tool with no annotations and no per-field documentation, the definition leaves an agent guessing about scope, partial-update semantics, and which call site is appropriate.

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?

Seven parameters at 0% schema coverage, and the description only gestures at 'conclusion' (matching one parameter) and vaguely 'header fields'. dut, setup, title, project, engineer, and description are undocumented in both schema and prose.

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

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

States a specific verb+resource: 'Update report header fields / overall conclusion', which tells an agent this touches report metadata rather than items or notes. It does not explicitly name or differentiate itself from siblings like report_edit_item or report_add_note, 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?

No when-to-use guidance, no prerequisites, no alternatives named. An agent cannot tell from the description whether this should be called before report_start, during an open report, or instead of report_edit_item.

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

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

With no annotations, the description carries the behavioral burden. It discloses that this starts a new report session whose folder receives later artifacts, and that rated_power_w triggers power-result checks. However, it does not describe permissions, whether a prior session is affected, or what happens if a report already exists.

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 short sentences are front-loaded with the core action and lifecycle effect. There is no wasted text, and the rated_power_w guidance is placed immediately after the main purpose.

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

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

An output schema exists, so the description need not explain return values. It still leaves gaps for a 7-parameter creation tool: most parameter meanings are undocumented, and prerequisites such as whether a report must be closed first are absent. It is adequate but not complete.

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

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

Schema coverage is only 43% across 7 parameters. The description mentions rated_power_w and gives a usage condition for it, but it does not explain the required title or the purpose of project, engineer, description, and other fields that lack 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 states a specific verb and resource: 'Start a new report session.' It clearly implies creation of a new report rather than opening an existing one, though it does not explicitly name report_open or other siblings as alternatives.

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 implied usage guidance by saying later screenshots, traces, and measurements are saved into the session folder, which tells the agent to start the report before capturing artifacts. It also gives a conditional usage note for rated_power_w, but it does not state when not to use this tool or explicitly compare it with report_open/report_list.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Show" implies a read operation, but the description does not explicitly confirm it is read-only, nor does it describe permissions, side effects, or what "active" means.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a parameterless status/report view tool.

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

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

The tool is simple, has no parameters, and has an output schema, so the description is adequate for invocation. However, with no annotations and no sibling differentiation, it remains somewhat under-specified about when this tool is preferable to report_list or report_open.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for a parameterless tool is 4.

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 ("Show") and resource ("active report and its items"), so the core action is clear. It does not distinguish itself from nearby siblings such as report_list, report_open, or report_start, which keeps it from 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?

There is no explicit guidance on when to use this tool versus alternatives like report_list or report_open. The word "active" implies it targets the current report, but the agent must infer that 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 the full behavioral burden, and it does disclose two important traits: a blocked path (File/Exit) and a confirmation gate on destructive-sounding items. It omits the mutation profile entirely (this drives an instrument GUI, so state likely changes), what confirm=true actually authorizes, and any error behavior. Partial but valuable 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?

A single compact sentence, front-loaded with the resource and its branches, then the guardrails. Nothing is padded or repeated. It is terse enough that a little more detail would have been welcome, but no sentence is wasted.

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?

An output schema exists, so return values need not be explained, and the blocked-path and confirm rules cover the main invocation hazards. What is missing is the mutation profile and relationship to sibling menu tools, which matters for a tool that manipulates an instrument UI with zero annotation coverage.

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 only 50% — 'path' is richly documented with examples, 'confirm' has no description at all. The description compensates by tying confirm=true to specific named paths (Power On State, Setting Mode, Fan/Display/Device), giving the undocumented boolean concrete meaning. That is real added value over 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 names the resource ('Application menu') and enumerates its top-level branches (File / Mode / System), which gives an agent real content to work with. However it states no verb (navigate? open? select?), and against siblings like sa_menu, sa_dialog, sa_file and sa_controls the boundary is left for the agent to infer. Purpose is identifiable but not sharply distinguished.

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 supplies genuinely useful conditional guidance: 'File/Exit is blocked' and 'Power On State, Setting Mode, Fan/Display/Device need confirm=true'. That tells the agent when a call will fail and when to set a flag, which is more than most menu tools offer. It still says nothing about when to prefer this tool over sa_menu or sa_press, so usage is implied rather than routed.

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

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

With no annotations, the description carries the full behavioral burden. It adds useful context that it reads the displayed trace (not a fresh acquisition) and mirrors SAStudio4's Channel Power method, but it does not state that it is a non-destructive read, whether a live connection/configured mode is required, or any rate/side-effect behavior. Some value, but a real gap for an unannotated 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?

A single front-loaded sentence: the core definition comes first, with the SAStudio4-equivalence and Max Hold note as a compact parenthetical. No filler, though the parenthetical is slightly dense.

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?

An output schema exists, so return values need not be described, and the measurement window is well specified. Still, with zero annotations and no mention of connection/prerequisite state or how the optional trace/add_to_report parameters affect behavior, the definition leaves an agent guessing about invocation context.

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

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

Schema description coverage is only 33% (center and bandwidth documented), so the description must compensate. It does clarify the two required parameters by defining the integration window as center ± bandwidth/2, which is genuinely additive. The remaining four parameters (note, label, trace, add_to_report) get no explanation in either place, though their names and defaults are largely self-evident.

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 gives a specific measurement verb (channel power integrated) plus the exact integration window (center ± bandwidth/2) and the data source (the displayed trace). This clearly separates it from a whole-span measurement, but it never names the closest sibling (sa_total_power) or sa_channel_table, so sibling differentiation is left to inference.

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 hints at operating conditions — 'works on Max Hold and any span' — which tells the agent the measurement is robust across acquisition modes. However it gives no explicit when-to-use guidance versus sa_total_power or sa_channel_table, and no prerequisites (e.g. must be connected and have a displayed trace) are stated.

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

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

With no annotations, the description carries the full burden. It discloses useful traits beyond structure: the measurement comes from a single trace read, it assumes a regular/evenly spaced plan, and Max Hold is needed for hopping signals. It omits instrument-state side effects, whether a connection/configure step is a prerequisite, and the reporting side effect implied by add_to_report.

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 tight sentences with zero filler; the core measurement is front-loaded and the operational parenthetical is placed exactly where it helps.

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?

An output schema exists, so not spelling out return format in depth is acceptable, and the description still names the key outputs. But for an 8-parameter measurement tool with no annotations and 50% schema coverage, the definition should say more about prerequisites (connected/configured instrument) and sibling routing.

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 only 50% (label, note, trace, add_to_report are bare). The description adds essentially no parameter meaning beyond noting a single trace read, so four undocumented parameters remain opaque to the agent.

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

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

States a specific measurement (channel power and peak) applied to a specific resource (a regular channel plan, from one trace read), which is more than a restatement of the name. It implies a boundary against the sibling sa_channel_power/sa_peak_table but never names the alternative, so an agent cannot fully disambiguate the family.

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?

Gives one concrete usage condition: use a Max Hold trace for hopping transmitters, which is genuinely useful procedural guidance. However, it never says when to choose this over sa_channel_power, sa_peak_table, or sa_total_power, leaving sibling selection 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 carries the full burden and does solid work: it discloses partial-update semantics ('only the given parameters change'), that it returns resulting settings, how parameters are reinterpreted per mode (HARM/PN/IQS/DET), and the offset-then-reference-level ordering. It doesn't cover failure behavior or persistence, so not a 5.

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?

Purpose is front-loaded in the first sentence and the remaining sentences each carry non-obvious operational detail (mode mapping, offset ordering). The ref_level example is long but earns its place by resolving an easy-to-misuse parameter.

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 an 11-parameter, all-optional configure tool with an output schema, the description covers the tricky parts (per-mode parameter meaning, ref level semantics, partial updates). Its main omission is routing guidance relative to sa_set/sa_mode, which keeps it short of a 5.

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 100% so the baseline is 3, but the description adds genuine meaning beyond the schema: it explains that span maps to analysis bandwidth in IQS/DET and to HARM span/level in HARM/PN, and it clarifies the input-vs-on-screen distinction for ref_level_dbm with a concrete attenuator example.

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

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

States a specific verb and resource ('Set up the analyzer') with a scope qualifier ('any mode') and adds per-mode detail about which controls each mode uses. It does not, however, explicitly distinguish itself from settings-adjacent siblings like sa_set, sa_mode, or sa_controls, so an agent must infer the boundary.

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?

Usage is implied rather than stated: 'Only the given parameters change' signals a partial-update configure call, and the mode notes hint at when different parameters apply. With 30+ siblings including sa_set and sa_mode, the absence of any explicit when-to-use-this-vs-that guidance is a real gap.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost none of it: nothing about failure behavior if the bridge is unreachable, whether the connection persists, idempotency, timeouts, or whether it is a prerequisite for other sa_* tools. 'Connect' implies a stateful setup but that is entirely inferred.

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 front-loaded sentence with no filler, and the target system is named first. Nothing can be trimmed 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?

An output schema exists, so return values need not be described. However, for a connection tool with no annotations and a large ecosystem of dependent siblings, the omission of prerequisites and connection lifecycle semantics leaves a meaningful 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 description coverage is 100% and the single host parameter is already documented as 'Bridge IP; blank = try PXE_HOST list'. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Connect) and a specific resource (the SCPI bridge in SAStudio4 on the PXE200), which is enough to distinguish it from data-oriented siblings like sa_scpi or sa_results. It doesn't explicitly contrast itself with the sibling it must precede, but the purpose is 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?

No guidance on when to call it, whether it must be called before sa_scpi/sa_status, or what state it establishes. The blank-host fallback is only implied via the schema, not explained in usage terms. An agent gets no routing help.

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 a genuinely important trait: the catalog comes from the survey and involves 'no instrument access', so calling it is side-effect free. It also warns that dialog controls are nested under a separate 'dialogs' key, which affects parsing. It stops short of describing result size or any refresh/staleness 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?

Two compact sentences, front-loaded with what the tool is and what it returns, followed by how to use the output. Dense but every clause carries information; no filler.

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?

An output schema exists, so return values need not be re-explained, and the description still usefully sketches the content shape and the 'dialogs' nesting. The one real hole is the undocumented include_generator flag, and there is no guidance on how large the catalog can be for a given mode.

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 75% and the description adds no per-parameter meaning beyond 'from the survey'. Notably, include_generator has no schema description and is not explained in the description at all, so a caller cannot tell what it toggles. Baseline 3 for high-ish coverage 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?

States a specific verb+resource ('Catalog of every control of a mode') and immediately enumerates the returned fields (name, caption, kind, options, location, risk class). It also differentiates itself from the consuming siblings by naming sa_get / sa_set / sa_press and noting dialog controls appear under a separate 'dialogs' key.

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 tells the agent the workflow context: this is a discovery tool whose names feed sa_get / sa_set / sa_press, and that it is survey-sourced with 'no instrument access' (so it is cheap/safe to call first). It does not explicitly contrast itself with sa_menu or sa_dialog, which also enumerate UI structure, so the routing is clear but not exclusionary.

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 does disclose that dialogs expose text and buttons and that you can answer or close them. However, it omits key behavioral traits for a UI mutation tool: whether calls block waiting for a dialog, what happens if the named window/button is not found, and whether answering is irreversible.

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

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

A single front-loaded sentence with no filler, stating the scope first and the actions second. The slash constructions ('dialogs / message boxes') are slightly informal but cost little.

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?

An output schema exists and schema coverage is full, so return values and parameter formats are covered elsewhere. The description is adequate for a three-parameter UI tool; only the missing dialog-vs-window scoping and blocking behavior keep it from being 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 coverage is 100%, so the schema already documents action, button, and window in detail; the description adds only the loose hint that buttons exist. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific resource (open dialogs / message boxes) and the actions available (see, answer, close), with parenthetical detail that dialogs carry text and buttons. It reads clearly on its own, though it does not explicitly differentiate itself from UI siblings like sa_controls, sa_menu, or sa_press.

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?

Usage is implied by the three actions (list dialogs, answer them, close them) but there is no explicit when-to-use guidance, no note that this applies to modal/blocking dialogs rather than app windows, and no routing to or away from 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 carries the full burden. It discloses that this drives a GUI dialog, the action sequence, and that it returns the folder listing, but omits important traits such as whether it blocks, GUI/session prerequisites, and overwrite/confirm side effects on save dialogs.

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 front-loaded sentence with a compact action list and a parenthetical trigger context; no filler. Slightly dense with the long parenthetical, but every clause 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?

An output schema exists, so return values need not be re-explained (it still notes the folder listing). However, for a GUI-driving tool with zero annotations, the description leaves behavioral gaps (blocking, prerequisites, destructive save effects) that an agent would want.

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 100%, so each parameter is already documented. The description's 'change folder, type a name or pick a file, confirm' adds workflow ordering but no meaning beyond what the schema already states for directory, name, select, and confirm.

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

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

States a specific verb (Drive) and resource (SAStudio4 file dialog) and lists the concrete actions (change folder, type/pick a file, confirm). It ties the tool to its triggering context via sa_app 'File/Save State' etc., though it does not explicitly distinguish itself from the similar siblings sa_dialog or sa_files.

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?

Gives clear context for when to reach for it: after invoking sa_app 'File/Save State' / 'File/Recall State', record path, replay file, or export. It does not name an alternative tool or an exclusion, but the trigger condition is unambiguous.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not state that the operation is read-only, that 'fetch' writes a file to the local report folder (a side effect), whether the PXE path requires access rights, or what happens on an invalid path. For a tool whose second mode has filesystem side effects, this is a meaningful gap.

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

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

A single front-loaded sentence with the two verbs first and the file-type examples in a compact parenthetical. No filler sentences and nothing wasted.

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?

An output schema exists, so return values need no explanation, and both parameters are schema-documented with defaults. Still, with no annotations and a sibling named 'sa_file', the description leaves the agent without the routing and safety context needed to choose and call this tool confidently.

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 100%, so both 'path' and 'fetch' are already documented in the schema, establishing the baseline of 3. The description adds the enumeration of file categories that clarifies what kinds of paths are meaningful, but contributes no syntax, defaults, or edge-case behavior 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?

States a specific verb pair ('List or download') and a specific resource ('files SAStudio4 wrote'), with concrete examples of what those files are (DataExport CSV/profile, images, state .xml, records). However, it does not differentiate itself from the close sibling 'sa_file', which an agent could easily confuse with this 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?

No guidance on when to use this tool versus 'sa_file', 'sa_read', 'sa_results', or 'sa_state'. The description implies a listing/download role but never names an alternative or a condition that selects this tool, so the agent must infer usage from the name alone.

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 does disclose one non-obvious trait: the tool 'navigates to it' before reading. However, it does not warn that supplying menu/mode/panel/dialog can switch the instrument's current mode or open a dialog, i.e. that a read can mutate UI/instrument state. No auth, timing, or failure behavior is mentioned.

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

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

A single front-loaded sentence with the verb first and the payoff (returned fields) last; no filler whatsoever.

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?

An output schema exists, so return values need not be explained, and the description does name them anyway. The gap is behavioral: for a 5-parameter tool whose optional selectors navigate modes, panels, and dialogs, the description never says that reading a control may change the instrument's UI state.

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 100%, so all five parameters are documented in the schema with examples (RBW_Hz, 'System/Preference', markerBtn). The description adds nothing about parameter meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('Read any control') and even enumerates the returned fields (value, options, caption, kind), which is unusually concrete. It does not, however, distinguish itself from adjacent siblings like sa_read, sa_results, or sa_state, so an agent must infer the boundary.

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 when-to-use statement, no prerequisites, and no mention of alternatives such as sa_set (the write counterpart) or sa_controls (which supplies the 'name' values). Usage is only implied by the verb 'Read'.

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. It usefully discloses one non-obvious behavioral trait, the menu-page visibility dependency and its two-step workflow, which the schema does not convey. However, it says nothing about connection state requirements, error behavior when a control name is wrong, or the side effects of the write-oriented actions (click/set/select).

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 essentially zero waste; the fallback role is front-loaded, and the menu prerequisite follows immediately. No restating of the name or title.

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?

An output schema exists, so return values need no explanation, and the schema fully documents the three parameters. For a high-complexity generic GUI-automation tool with many action modes and no annotations, the description covers the key menu prerequisite but leaves the per-action workflows and failure modes under-explained.

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 100%, so the baseline is 3. The description goes slightly beyond the schema by tying action=menu to the target menu-name values and to menu-page reachability, clarifying workflow rather than just enumerating the action list. It still does not explain the relationships among list/click/set/options/value/text beyond the schema's own hints.

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

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

States a specific verb+resource ('generic access to any SAStudio4 control by name') and carves out its niche as the fallback 'for settings without a dedicated tool', which distinguishes it from the many sibling tools like sa_set, sa_configure, and sa_menu. It is clear what the tool does, though 'control' is left somewhat abstract.

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?

Gives an explicit selection rule ('for settings without a dedicated tool') and an actionable prerequisite for the menu case ('Menu controls are only reachable while their right-hand menu page is shown: open it with action=menu'). It lacks an explicit inverse statement (e.g. 'do not use this for X, use sa_scpi instead'), which keeps it from a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only information retrieval by naming 'Instrument info' and listing observable values, but it does not explicitly state that it is non-mutating, whether it has side effects, or what the optional GNSS behavior means beyond the schema.

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

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

The description is a single front-loaded sentence that immediately identifies the subject as instrument info and then lists the returned fields compactly. There is no filler or redundant explanation, and every listed item 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?

An output schema exists, so the description need not explain return values; it still usefully previews the information available. The input schema fully covers the optional gnss parameter, and the description is complete enough for a simple info-retrieval tool, though it could mention the GNSS side effect or read-only nature.

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 100%, so the schema already fully documents the single optional gnss parameter. The description does not mention or clarify the gnss parameter at all, leaving the parameter semantics entirely to the schema; baseline 3 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 states a specific resource and enumerates the instrument information returned: model, UID, versions, temperature, USB link, battery, clock, current mode, and checked menu items. This is clearly an instrument-info getter, but it does not explicitly differentiate itself from similar siblings such as sa_status, sa_state, or sa_get.

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 when-to-use guidance, prerequisites, or alternatives are provided. The tool's purpose implies it is for retrieving instrument information, but the description never says when to choose it over sa_status, sa_state, or other read-oriented 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, the description carries the full behavioral burden. It mentions the return (marker table with x/y), but says nothing about the mutating actions (set, clear_all, on/off) changing instrument state, whether a connection is required, or consequences of destructive actions like clear_all. That is a significant gap for a stateful control tool.

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

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

Two sentences, front-loaded with the resource and scope, then the operation list and return format. Dense but efficient; the enumeration serves a purpose in conveying capability scope.

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 6-parameter, multi-action tool with an output schema (so return values needn't be explained), the description covers what the tool can do. It falls short on usage context and behavioral disclosure for a tool whose actions mutate state, leaving some gaps an agent would want filled.

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 83%, so the schema already documents the parameters (trace, value, action, marker, marker_type). The description's operation words loosely map to the 'action' enum values but add no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

The description names the resource precisely (markers on the current graph, any mode) and enumerates the operations the tool performs (enable, place, peak search, to_center, delta tracking, etc.), so an agent understands this is the marker-control tool. It does not, however, differentiate itself from nearby siblings like sa_peak or sa_peak_table, which overlap in the peak/marker domain.

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 explicit when-to-use guidance, no exclusions, and no routing to alternatives such as sa_peak_table for reading peaks or sa_peak for peak search. The operation list hints at capability but gives no condition for selecting an action over using a sibling tool.

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

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

With no annotations, the description carries the full behavioral burden, and it usefully discloses a genuine side effect: entering Channel Power can silently change span/RBW. However, it says nothing about whether this instrument-controlling call requires an active session, blocking/settle behavior, or what state persists — notable omissions for a measurement tool that mutates instrument state.

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

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

Two sentences, zero waste: the action is front-loaded and the hazard caveat follows immediately. Every 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?

An output schema exists, so return values need not be explained, and the description covers purpose plus the key state-change hazard. It stops short of covering prerequisites (connection state) and how the measurement variants relate to sibling tools, but it is close to sufficient for calling 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?

Schema coverage is 63% and the description adds no per-parameter meaning beyond the Channel Power span/RBW caveat; the 'kind' options and 'obw_xdb'/'chp_bandwidth' semantics live entirely in the schema. With 8 parameters and only partial coverage, the description leaves the undocumented fields (note, label, add_to_report) unexplained, but the baseline of 3 is warranted since the schema does much of the work.

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

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

States a specific verb+resource: 'Run one of SAStudio4's own measurements (Meas menu) and read its result', which tells an agent exactly what happens. It anchors the tool to the instrument's Meas menu, but does not differentiate it from siblings like sa_channel_power or sa_total_power, which cover the same measurement domains.

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?

Usage is only implied via the '(Meas menu)' anchor and the narrow set of measurement kinds, so an agent can infer this is for SAStudio4's built-in measurement modes. There is no explicit when-to-use statement and no guidance on choosing this over sa_channel_power/sa_total_power, which is a real gap given the overlap.

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

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

No annotations are provided, so the description carries the full disclosure burden. It hints at output content ('values, options, risk') but says nothing about side effects of opening a menu or the 'Switch to this mode first' behavior, reversibility, or permissions. Substantial behavioral gaps remain.

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

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

A single front-loaded sentence with no wasted words. The action and its return are stated 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?

With no output schema and no annotations, the description partially compensates by naming the returned control data, but for a 4-parameter interaction tool it omits side-effect and mode-switching behavior, leaving the agent under-informed on how opening a menu affects application state.

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 75% with inline descriptions for menu, mode, and page, so the schema does most of the work; 'screenshot' lacks a description. The tool description itself adds no parameter meaning beyond what the schema already states, so the baseline 3 applies.

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

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

States a specific verb+resource ('Open a right-hand menu') and what it returns ('live controls'), so the purpose is legible. However, it does not distinguish itself from close siblings like sa_controls or sa_dialog, which also deal with menus/controls, leaving some ambiguity about when this tool versus those apply.

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 explicit when-to-use, when-not-to-use, or alternative routing. The phrase 'right-hand menu' implies context, but an agent gets no guidance on how this differs from sa_controls, sa_dialog, sa_gui, or sa_press.

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

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

With no annotations, the description carries the full behavioral burden. It says the tool switches modes but does not disclose side effects such as whether an active measurement is interrupted, whether settings reset, or what happens with invalid modes.

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

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

The description is a single concise sentence with no wasted words and is front-loaded. It could be slightly more structured, but it is appropriately sized for a simple mode-switching tool.

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?

An output schema exists, so return values need not be explained, and the parameter schema fully documents the mode options. However, the lack of annotations and missing usage or side-effect context leave the definition only minimally complete for a state-changing 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 100%, and the single mode parameter is fully documented with allowed values in the schema. The description adds no additional parameter semantics beyond what the schema already provides, so baseline 3 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?

States a specific verb and resource: switching the SAStudio4 measurement mode. It is clear what the tool does, but it does not differentiate itself from siblings like sa_configure or sa_measure.

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?

Provides no explicit guidance on when to use this tool versus alternatives. The purpose implies usage, but there are no conditions, prerequisites, or sibling references to help the agent choose correctly.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the bare operation. It never says the call is read-only, that show_marker=true causes a visible side effect on the instrument display, or what the returned peak representation contains. Only the parameter's own schema text hints at the marker side effect.

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, front-loaded sentence with no filler or restated boilerplate. It is arguably too terse for a tool with a side-effecting flag, but it wastes no 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?

An output schema exists, so return values need not be explained, and the input schema covers most parameters. However, with zero annotations and a boolean that mutates on-screen state, the description leaves the agent without a safety/behavior profile for a four-parameter instrument 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 75%, so the start/stop/show_marker semantics are largely handled by the schema itself (baseline 3). The description only adds the 'optionally within a range' framing for start/stop and says nothing about the undocumented 'trace' parameter or value formats for start/stop (number vs string).

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

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

The description names a specific operation on a specific resource: finding the highest point of the trace, with the optional range qualifier. An agent can distinguish this from siblings like sa_peak_table or sa_marker by the 'single highest point' semantics, though the description never names or contrasts those alternatives 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 only usage hint is the parenthetical '(optionally within a range)', which implies start/stop semantics but does not state when to use this over sa_peak_table, sa_marker, or sa_measure. No exclusions, prerequisites, or context conditions are given.

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, so description carries the burden. It discloses that this mutates UI state (turns the table on) and what it reads (10 strongest peaks with three fields), which is useful. But it doesn't say whether the state persists, what happens if already on, or permission 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?

Single front-loaded sentence with the action and result fields; zero 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?

Output schema exists so return values needn't be re-explained (though it lists them redundantly). With one parameter and an implied stateful toggle, the key missing piece is the meaning of show and whether reading depends on visibility, which leaves the definition only minimally 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 single 'show' parameter has 0% schema coverage and the description never explains it. 'Turn on' implies show=true, but the semantics of show=false (hide? suppress display yet still read? disable?) are left completely 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?

States specific verb and resource: turns on SAStudio4's Peak Table and reads the 10 strongest peaks with named return fields (n, frequency, level). Clear what it does, but doesn't explicitly differentiate from siblings like sa_peak or sa_marker.

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 vs sa_peak, sa_marker, or sa_trace_data. Usage is only implied by the description; no exclusions, prerequisites, or alternatives named.

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

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

With no annotations, the description carries the full burden. It usefully discloses a non-obvious behavior — "Reports dialogs it opened" — but omits that pressing buttons mutates application state, whether a dialog-opening press blocks, and how the dialog/answer/confirm parameters participate in that flow.

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 short sentences with no filler; the core action is front-loaded ahead of the behavioral note. "Any SAStudio4 button" is slightly loose but the parenthetical immediately constrains it.

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 an 8-parameter tool with a rich output schema, the description covers the basic action adequately and return values need not be explained. However, the multi-step dialog interaction (dialog, answer, confirm) is the most complex aspect and goes unaddressed, leaving the workflow 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?

Schema description coverage is 88%, so the schema already documents nearly every parameter (menu, mode, panel, dialog, option, answer, confirm). The description adds only the mapping of "momentary actions, menu buttons" to the button kinds, which is marginal 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?

States a specific verb ("Press") and resource ("SAStudio4 button") and scopes it to momentary actions and menu buttons, which distinguishes it from generic navigation tools. It does not explicitly name the closest siblings (sa_menu, sa_dialog, sa_controls), so it falls short of full sibling differentiation.

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 statement of when to use this tool versus sa_menu, sa_dialog, or sa_controls, and no mention that button names come from sa_controls. Usage is only implied by the parenthetical scoping of button kinds.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully details what each category contains (labels are result values/annotations; tables include peak/harmonic/SEM/mapping/pulse; plots include trace point counts), but never states read-only/non-mutating nature, permissions, or limits.

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

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

A single front-loaded sentence with a dense but purposeful list of categories; no filler and the core purpose leads.

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?

An output schema exists so return values need no explanation, and both params are documented. Coverage of the read categories is good; the only gap is the absence of read-only/side-effect disclosure for a zero-annotation 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 100%, so baseline is 3, but the description adds meaning beyond the enum by explaining what each 'what' category actually returns (e.g., tables = peak/harmonic/SEM/mapping/pulse). The 'scope' widget filter is only loosely implied.

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

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

States a specific verb and resource ('Raw readouts of what is on screen') and enumerates the retrievable categories (labels, tables, plots, windows, device info, widget tree). This is clear, but it does not differentiate itself from read-oriented siblings like sa_get, sa_results, or sa_state.

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 enumeration implies when each 'what' value applies, but there is no explicit when-to-use versus alternatives (e.g., sa_get, sa_results, sa_screenshot). Usage is inferred rather than directed.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing beyond return content. It does not say that 'mode' changes instrument state, nor that 'add_to_report' writes into a report (a side effect), nor whether reading is safe/non-destructive. The mention of notices and overflow is the only behavioral flavor added.

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 scope statement is front-loaded in the first clause, and the long enumerations map to actual measurement coverage rather than filler. It is a single dense sentence with no boilerplate, though the comma-separated list borders on being a data dump.

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?

An output schema exists, so return values need not be explained, and the description does cover the breadth of returned data. However, for a no-annotation tool with three undocumented parameters and mutation-adjacent options (mode switch, add_to_report), the definition leaves an agent without enough context to call it confidently.

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 only 25%: only 'mode' is documented, while note, label and add_to_report are opaque. The description says nothing about any of the four parameters, so it fails to compensate for the coverage gap on a tool where three parameters have no explanation anywhere.

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

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

The description names a concrete resource ('All results SAStudio4 currently shows, parsed') and enumerates the measurement domains covered (SA, IQS/DET, PN, HARM, MAP), so an agent knows this is the aggregate results reader. It is clear what data is retrieved, but it never distinguishes itself from siblings such as sa_channel_power, sa_measure, sa_trace_data or sa_peak_table, which could plausibly return overlapping subsets.

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 statement of when to use this tool versus alternatives, no prerequisites (e.g. an active measurement), and no exclusions. Given a crowded sa_* family with per-measurement siblings, the absence of any routing guidance is a real gap.

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, so the description carries the full burden. It usefully discloses the query convention and the exact set of supported commands (a real capability boundary), but says nothing about error behavior on unsupported commands, whether sa_connect must precede it, or how blocking commands (SWE:WAIT?, *OPC?) behave.

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 core rule is correctly front-loaded in the first sentence, and the command list is arguably necessary information. However, it is dumped as an unbroken run-on wall of mnemonics with no grouping or line structure, making it hard to scan.

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?

An output schema exists, so return values need no explanation, and the command surface is well covered. What is missing for a low-level bridge tool in a large tool family is prerequisite state (connection, mode) and any indication of what to do when a command fails or is unsupported.

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 only 50%, and the description compensates substantially: it enumerates the valid command strings and gives a concrete example format ('FREQ:CENT 915MHz' / 'BAND?'), which is far richer than the schema's one example. The remaining gap is timeout_s, whose units and semantics are left entirely to the name and its default of 60.

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 first sentence gives a specific verb and resource – send a raw SCPI command to the bridge – and the parenthetical clarifies the query convention ('queries end with ?'). It is clear what the tool does, but it never contrasts itself with the many higher-level siblings (sa_get, sa_set, sa_configure, sa_marker), so an agent cannot easily tell when this escape hatch beats 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?

There is no explicit when-to-use, when-not, or alternative routing. Given ~30 sibling tools that partly overlap (sa_get/sa_set/sa_trace/etc.), a raw-command escape hatch is exactly the tool that needs 'use this only when no high-level tool covers the operation' guidance, and none is given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the screenshot is saved to the report folder, but it does not explain side effects, overwrite behavior, filename generation, permissions, or what return_image changes. For a capture tool with no annotation coverage, this is a significant gap.

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

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

The definition is a single front-loaded sentence with no filler. The parenthetical adds useful save-location and settings context without becoming 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?

There is no output schema and no annotations, and one parameter is undocumented in the schema. The description does not explain return behavior, image-return semantics, file naming, or report integration details, leaving an agent with insufficient context for a three-parameter capture 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 67%, with note and label documented but return_image left undescribed in the schema. The description adds no parameter-level meaning, mentioning only 'current settings' and not explaining how note, label, or return_image affect the capture or report. It does not compensate for the uncovered parameter.

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

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

The description states a specific verb and resource: 'Capture the SAStudio4 screen as PNG.' It also specifies the output format and save location, making the tool's purpose clear. It does not explicitly differentiate itself from siblings like sa_view or sa_file, but the screenshot-specific operation is 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 implies report usage by saying the PNG is saved to the report folder, but it gives no explicit when-to-use guidance or alternatives. It does not say when this tool should be preferred over sa_view, sa_file, or report_export.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses read-back behavior and that mode-switching confirmation pop-ups are cancelled and reported, but it does not cover permissions, destructive impact, persistence, or failure behavior beyond what the schema already implies.

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 two tight sentences, front-loaded with the main action and followed by a key behavioral nuance. Every sentence adds useful information with no wasted wording.

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

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

Given the rich input schema, existing output schema, and 100% parameter description coverage, the description provides enough high-level context for an agent to understand the tool's role and key side effect. It falls short only in not explicitly routing between related sibling tools.

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

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

Schema description coverage is 100%, so the detailed parameter descriptions already carry the semantic load. The description mentions that values are number / choice / on-off controls, but adds little beyond the schema's examples and documentation.

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

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

The description states a specific verb ('Set') and resource ('any SAStudio4 value control'), with the target narrowed to number / choice / on-off controls. This implicitly distinguishes it from sibling tools that read (sa_get), press buttons (sa_press), or navigate dialogs (sa_dialog).

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 by scoping it to value controls and explaining that confirmation pop-ups that would switch mode are cancelled and reported. However, it never names alternatives such as sa_press, sa_dialog, or sa_configure, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the operation names. The critical facts that recall replaces the whole setup and that save can overwrite live in the schema's confirm parameter, not the description, and no permissions or side effects are disclosed here.

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

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

A single compact sentence with the verb list front-loaded and zero filler. It is efficiently sized, though it is arguably terse enough that it under-serves a state-mutating tool.

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?

An output schema exists, so return values need not be explained, and the schema covers all parameters. However, for a tool that can overwrite and wholesale-replace setups with no annotations, the description leaves behavioral gaps an agent would want filled.

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 100%, so the schema already documents name, action, and confirm in detail. The description adds no syntax, format, or value guidance beyond what the schema supplies, making the baseline 3 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?

States three concrete verbs (save/list/recall) against a specific resource (complete SAStudio4 setups) and anchors it to the GUI menu path, so the agent knows exactly what the tool manages. It does not, however, differentiate itself from plausible siblings like sa_file, sa_files, sa_get, or sa_set.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternative. The menu-path reference implies context but does not help the agent choose between sa_state and the file/get/set 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 behavioral burden, and it discloses almost nothing: it never states that this is a non-mutating read, whether a live connection/session is required, or what happens if the instrument is disconnected or in an unexpected mode. Listing return fields is not 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?

It is a single compact fragment with no padding, which is efficient, but the absence of any verb or framing sentence means it reads as a field dump rather than a properly front-loaded definition. Brevity here comes at the cost of clarity, not from good editing.

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?

An output schema exists, so the description is not obligated to explain return values, and for a zero-parameter read the required coverage is small. Still, the description effectively restates output field names while omitting any statement of the tool's action or preconditions, leaving it only minimally 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 tool takes zero parameters, so there are no parameter semantics to explain. Baseline of 4 applies; nothing in the description misleads about inputs, and additionalProperties:false confirms a parameterless call.

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 enumerates the fields the tool reports (mode, frequency range, RBW/VBW, reference level, offset, ADC overflow), which conveys that this is a current-instrument-status read. However, it is a bare noun phrase with no verb, and it does nothing to distinguish sa_status from sibling tools like sa_info, sa_state, or sa_get, which likely read overlapping state.

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 statement of when to use this tool versus alternatives such as sa_info, sa_state, sa_results, or sa_get. The agent must guess from the field list alone whether this is the canonical status query or a niche subset.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one useful trait — that single blocks and returns when the sweep is complete — but says nothing about continuous or wait behavior, whether the call is blocking, whether it disrupts an in-progress acquisition, or any permission/rate considerations.

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?

It is very brief, which is good, but the lead fragment "Run control." is low-value filler and the one informative sentence is buried after it. Nothing is padded, but the front-loading is weak.

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?

An output schema exists, so return values need not be described. However, for a two-parameter control tool with zero annotations, the description omits essential behavioral context (blocking semantics for the other modes, interaction with ongoing measurements), leaving the agent under-informed.

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 100%, so the schema already documents both parameters (action values and sweeps). The description adds only marginal clarification about the single action's completion semantics, which is the expected baseline when the schema does the heavy lifting.

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?

"Run control" is a vague categorization rather than a specific verb+resource; the description never plainly states that the tool drives/starts a sweep acquisition. It only partially clarifies one mode (single) rather than the tool's overall purpose, and does nothing to distinguish it from siblings like sa_measure, sa_status, or sa_configure.

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 when-to-use guidance and no alternatives named. The reader cannot tell from this text when to pick sa_sweep over sa_measure or sa_status, nor when continuous versus wait is appropriate beyond the terse schema notes.

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 so well: it discloses side effects (restoring detector and trace type), automatic validation against the DUT rating, and returned warnings on mismatch. It omits any auth/permission or rate-limit context, but the operational behavior is unusually well covered.

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 method, validity rule, and prerequisites lead the description, so the important routing information is front-loaded. It is dense but each sentence carries substantive content; the trailing environment/prerequisite sentences are slightly less essential but not wasteful.

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?

An output schema exists, so return values need not be explained, and the description covers method, warnings, and prerequisites adequately. The one soft spot is that the 'offset (attenuator)' setup instruction references something not present in the schema, leaving an agent to resolve it out-of-band.

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 57%, so roughly half the parameters rely on the schema. The description adds the span coverage requirement (mapping to bandwidth) and mentions an 'offset (attenuator)' that does not actually appear as a parameter, and it omits hold_s, label, note, and add_to_report entirely. It adds some meaning but leaves real gaps and one ambiguous reference.

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

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

The description states a specific measurement (absolute band power) and details the method (RMS detector + Average trace with a peak cross-check), which clearly differentiates it from simpler siblings like sa_peak or sa_channel_power by intent. However, it never explicitly names a sibling or contrast case, so the agent must infer the distinction from domain knowledge.

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 a prerequisite ('Set the span so the whole signal is inside it, and the offset before calling') and a validity rule (only RMS is valid when peak/RMS differ >3 dB), which implies usage context. But it never says when to choose this tool over sa_channel_power or sa_measure, nor any exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one temporal trait (accumulating for hold_s seconds), but omits material side effects: the default `restart=true` clears the trace, and the call is presumably blocking for hold_s seconds. Mutation scope (which traces/state are affected) and any permission or sweep-state requirements are unstated.

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

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

A single, front-loaded sentence with no filler; the primary action leads and the optional hold behavior follows. It is appropriately sized, though the terse parenthetical is doing double duty as the only usage hint.

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?

An output schema exists, so return values need not be explained, and all four parameters are described in the schema. However, for an unannotated state-mutating tool with a default-clearing `restart` flag and a potentially blocking hold duration, the description stops short of the behavioral context an agent needs.

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 100%, so `trace`, `restart`, and `trace_type` enum members are already documented in structured data, establishing a baseline of 3. The description adds only mild value by framing hold_s as accumulation time and MaxHold as the bursty-signal case, without new syntax, ranges, or interaction rules.

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

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

States a specific verb and resource ('Set a trace's type') and adds a concrete use-case cue for MaxHold ('hopping/bursty signals'). It is clearly a trace *configuration* tool, distinguishable from the read-oriented `sa_trace_data`, but it never names or contrasts with that 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?

Usage is only implied: the parenthetical '(Max Hold for hopping/bursty signals)' hints when MaxHold is the right choice, and 'optionally accumulate for hold_s seconds' hints at the hold workflow. There is no when-to-use/when-not guidance and no reference to alternatives such as `sa_trace_data` or `sa_sweep`.

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 does disclose a side effect ('Saves CSV + plot') and value semantics ('values include amp offset', 'X in seconds'). However it does not say whether it mutates device state or requires write access, and the save side effect largely restates the schema's own `save` description.

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?

Four compact sentences, purpose front-loaded, no filler. Some phrases are telegraphic ('Spectrum graphs: peak, band power, occupied ranges') but each still earns its place by scoping the return values.

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?

Output schema exists so return format needn't be explained, and the description usefully classifies graph types. But for a 9-parameter, annotation-free tool it omits the read-vs-write posture, the relationship of `save` to the active report, and unit/format expectations for start/stop.

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 78%, so the schema already documents most parameters (plot, save, start/stop, trace, occupied_db, return_points). The description adds nothing parameter-specific — `note` and `label` remain unexplained in both places — so it sits at the baseline for high 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?

States a concrete verb+resource ('Read a displayed trace of any graph') and specifies the data family in scope (spectrum graphs vs time graphs DET PvT/IQS IQ). It never distinguishes itself from the nearby sibling sa_trace, so an agent must infer which one to call from name alone.

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 when-to-use / when-not-to-use guidance and no named alternative among the many siblings (sa_trace, sa_read, sa_sweep, sa_marker). The spectrum-vs-time sentence explains what the returned values mean rather than when this tool is the right choice.

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

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

With no annotations, the description carries the full behavioral burden, yet it says nothing about side effects, permissions, whether hiding is persistent, or what happens when a name doesn't match. Show/hide are state mutations and that risk is 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?

A single compact sentence with the three supported operations front-loaded and no filler. It is efficient, though its brevity reflects under-specification rather than tight prose.

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?

An output schema exists, so return values need not be explained, and the parameters are fully covered by the schema. The remaining gap is behavioral and routing context, which the description does not supply for a state-mutating UI 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 description coverage is 100% and both parameters are fully documented in the schema (on: true=show/false=hide; name: blank = just list). The description adds no syntax or format meaning beyond that, so the baseline 3 applies.

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 pairs specific verbs (list/show/hide) with a concrete resource (dock views of the current mode), so an agent understands the operation. It stops short of distinguishing itself from adjacent UI-manipulation siblings like sa_gui, sa_controls, or sa_menu, so it isn't 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 when-to-use, when-not-to-use, or alternative routing is given. The agent must infer that this tool is the one for dock-view visibility rather than sa_gui or sa_controls, which is not stated anywhere.

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