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

Annotations cover safety profile, and the description adds substantial behavior: it uses analog AM path 1, disables ARB/IQ and competing modulation, documents rate/depth ranges, states RF stays OFF unless rf_on=True, and clarifies that stored voice waveforms are not altered.

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

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

The description is front-loaded with purpose, then adds constraints and side effects in four short sentences. Every sentence provides useful operational context without rephrasing 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?

For a 5-parameter mutation tool with no output schema, the description covers side effects, ranges, RF default behavior, and persistence limits well. However, missing semantics for the required frequency_hz and level_dbm parameters leaves a notable 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 0%, so the description must carry parameter meaning. It documents rate (0.1–50000 Hz), depth (0.1–100%), and rf_on behavior, but omits frequency_hz and level_dbm, both of which are required parameters.

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

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

States a specific verb and resource: configure ordinary sine-tone AM with adjustable front-panel depth. It distinguishes itself from voice playback and from stored waveform operations, and identifies the analog AM path and disabled competing modes.

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?

Clearly implies when to use it: to replace voice playback with a sine tone without altering the stored voice waveform. It does not explicitly route the agent among siblings like set_am_depth or play_waveform, but the operational context is clear.

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

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

Annotations establish the safety profile (not read-only, idempotent, non-destructive), and the description adds substantial value beyond them: RF settings are preserved, front-panel control is restored by default, reconnection is automatic, and server exit closes the port without turning RF off. The only gap is what happens to any in-flight or pending state at disconnect time and what the call returns (no output schema 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?

Four short sentences, each load-bearing: the primary effect first, then the default behavior, then the auto-reconnect consequence, then the server-exit edge case. No filler and no repetition of structured fields.

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

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

For a one-parameter, non-destructive disconnect tool, the description covers the side effects, the default behavior, and the reconnection model an agent needs. It omits only the return payload and any pending-operation semantics, which is a minor gap given the annotations already flag idempotency and non-destructiveness.

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

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

Schema description coverage is 0% for the single return_local parameter, so the description must compensate. 'By default also return front-panel control' strongly implies the default-true behavior of return_local, but the parameter is never named and the false case (leaving the instrument in remote/controlled mode) is left to inference.

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?

Names a specific action (release the adapter) and its resource, and immediately frames the benefit (so another client can use it) plus what is preserved (RF settings). An agent can distinguish it from adjacent tools like get_status or set_rf, though it never names a sibling explicitly as the alternative.

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

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

Gives a clear context for use ('so another client can use it') and explains that a subsequent status/control call transparently reconnects, which is effectively guidance on when not to bother worrying about reconnecting. It stops short of stating explicit exclusions or pointing to a sibling tool for related tasks.

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

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

Annotations already declare readOnlyHint/destructiveHint=false, so safety is covered; the description still adds value by stating the tool will not reset, clear errors, or change generator settings, and that it connects lazily and enumerates exactly what full=True inspects. It stops short of describing return format or latency/connection-reuse 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?

Front-loaded with the core action, then the full=True delta, then the non-side-effects guarantee — a logical order. The long enumeration of checks is dense but each item distinguishes the mode, so it largely earns its space.

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

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

With no output schema, the description at least hints at the return ('diagnostic notes'), and it fully covers the single parameter and safety profile. A bit more on what the diagnostic output looks like would make it complete for an agent consuming the result.

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

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

Schema coverage is 0% and the sole parameter 'full' is undocumented in the schema, so the description carries the burden — and it does, spelling out that full=True adds I/Q source, modulation paths, ALC, high-crest, clocks, trigger, offsets, and blanking checks. Only the default/true-false semantics are left to the schema's default field.

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?

Specific verb+resource: reads instrument identity, installed options, and live settings from an E4433B generator, with a stated expanded mode via full=True. It implicitly separates itself from siblings like read_errors by noting it does not clear errors, but it never names an alternative tool 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 implied rather than stated: 'Connect lazily' and 'full=True also checks...' tell the agent how to vary depth, but there is no explicit when-to-use-this-vs-sibling guidance (e.g., versus scpi_query or read_errors). Adequate but leaves routing 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?

Annotations already cover the read-only/non-destructive safety profile, so the bar is lower, yet the description goes well beyond them. It discloses that the read 'can take minutes,' 'may interrupt playback,' that marker/sequencer bits 'can change raw hashes without changing the lower 14-bit audio samples,' and that it 'does not measure RF output' – rich timing, side-effect, and semantic caveats an agent cannot get from structured fields.

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 action ('Read stored I/Q samples and report hashes/ranges without modifying them') followed by caveats, each of which earns its place. Slightly more verbose than strictly necessary but nothing 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?

For a one-parameter read tool with no output schema, the description is behaviorally thorough: it covers timing, playback interruption, hash variance from marker bits, and non-measurement. The only shortfall is that the 'name' parameter's semantics are left entirely to the schema title.

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

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

Schema description coverage is 0% for the single 'name' parameter and the description contributes no parameter information beyond 'Read stored I/Q samples.' With coverage this low the description is expected to compensate, and it does not – the agent gets no format, constraint, or meaning for 'name'.

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

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

States a specific verb and resource: 'Read stored I/Q samples and report hashes/ranges without modifying them.' The purpose is concrete and distinguishable, and 'This does not measure RF output' clarifies the boundary. However, it never names the closest sibling (list_waveforms/play_waveform) to route the agent explicitly, 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?

There is no explicit when-to-use or when-not-to-use statement. The only guidance is the negative 'This does not measure RF output,' which implies the tool is for inspection rather than measurement. Usage is left to inference rather than stated against 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds the useful nuance that ports are not opened (no exclusive resource acquisition) and instrument state is untouched, but it says nothing about failure modes, environment enumeration, or what happens if no adapters exist.

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

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

A single front-loaded sentence with no filler; the resource leads and the side-effect guarantee follows. 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?

For a zero-param, closed-world list tool this is nearly sufficient; the annotations carry the safety story. The only gap is that, with no output schema, the description does not indicate what an adapter entry contains (name, port, serial number), leaving the return shape to inference.

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?

Zero parameters, so per the rubric the baseline is 4. There is no parameter surface for the description to clarify or omit.

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 ('List USB serial adapters'), which is unambiguous and matches no other tool in the sibling list. It does not explicitly name a sibling it differs from, but no sibling overlaps in resource, so the distinction is implicit rather than stated.

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 clause 'without opening ports or changing the instrument' implies a discovery/pre-flight use case, but the description never says when to call it versus alternatives (e.g., versus a connect/open flow, or before set_rf_* calls). Usage is implied rather than stated, and no exclusions 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?

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds the detail that manuals are 'local' and 'Markdown conversions' with coverage and page counts, which is useful context beyond annotations. However, it does not describe ordering, pagination, or output format, leaving some behavioral gaps.

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

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

A single sentence that front-loads the verb and resource and packs in the return contents without waste. Appropriately sized for a no-parameter list operation.

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

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

For a zero-parameter read-only list tool with no output schema, the description covers the essential purpose and return shape (sources, coverage, page counts). It could note sorting/ordering or that it lists local originals only, but nothing critical is missing.

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

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

There are zero parameters, so the baseline is 4. The description correctly adds no parameter claims and simply explains what data the tool returns.

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

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

States a specific verb (List) and resource (local original-manual Markdown conversions), and enumerates what is returned (sources, coverage, page counts). Distinguishable from search_manuals and read_manual_pages by the word 'List' and 'local', though it doesn't explicitly contrast with those siblings.

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

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

The description implies usage (browse available manuals with metadata) but gives no explicit when-to-use or when-not-to-use guidance, and does not name alternatives like search_manuals for filtered queries.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the description's added value is the UND-option prerequisite and the volatility warning that waveforms can vanish after power-off. That is meaningful behavioral context beyond the structured fields, though it omits error behavior if the option is missing.

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

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

Three short sentences, front-loaded with the purpose and prerequisite before the caution. Slightly redundant: 'can disappear after power-off' and 'never assume yesterday's waveform still exists' restate the same volatility point.

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

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

For a zero-parameter, no-output-schema listing tool, the description covers purpose, prerequisite, and the key volatility caveat. It could still say what the listing returns (names? slots?), which is the only remaining 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?

The tool takes no parameters, so by the scoring baseline this is a 4. Nothing in the description conflicts with the empty 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 and resource with a scope qualifier: 'List existing volatile ARB waveforms'. An agent immediately knows this enumerates waveforms rather than inspecting or playing one. It stops short of 5 because it never names the adjacent siblings (inspect_waveform, play_waveform) that a caller might confuse it with.

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 call it ('Check this before restoring playback; never assume yesterday's voice waveform still exists') and states a prerequisite ('Requires installed UND option'). It does not name alternatives or state when not to use it, so it falls short of the 5 threshold.

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

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

Annotations only declare it is a non-readonly, idempotent, non-destructive, non-open-world mutation. The description goes well beyond that by enumerating the instrument state it resets (internal I/Q and clock, master modulation, continuous trigger, crest mode, no gating/blanking or competing analog modulation, ALC off, fixed-reference power search) and by clarifying it does not alter samples and that modulation depth comes from the waveform rather than the AM menu.

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 key facts (purpose, worked parameter example, rf_on rule) are front-loaded and every later sentence conveys state-setup or scope information. It is slightly redundant in restating 'Restore... Restores...', but no sentence is 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?

For a non-readonly, no-output-schema state-restoration tool, the description covers what state is changed, what is left untouched, and how to invoke it with concrete values. Missing only edge-case behavior such as error handling for an unknown waveform name or interaction with prior playback, which is minor given the 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 description coverage is 0%, so the description must carry parameter meaning, and it does: it supplies concrete values for all four required parameters (name='VOICE_T12', sample_rate_hz=16000, frequency_hz=750000, level_dbm=-10) and explains rf_on's semantics. It does not state units, ranges, or what happens if the waveform name does not exist, so it is strong-but-not-complete compensation.

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

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

The description opens with a specific verb+resource+scope: 'Restore a complete continuous I/Q playback setup using an existing waveform.' That is clearly distinguishable from siblings like upload_am_wav, inspect_waveform, and list_waveforms, since playback state restoration is a different action from uploading or inspecting.

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 an explicit conditional instruction for rf_on ('Specify rf_on=True only when output is requested') and a negative scope statement ('Does not upload or modify samples'), which steers the agent away from upload tools. It never names an alternative sibling or prerequisites (e.g. that the waveform must first be listed), so it stops short of full when/when-not 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?

The annotations declare readOnlyHint=false, and the description explains exactly why: reading is destructive to the queue because it consumes/removes errors. It further discloses that no *CLS or preset is sent and that configuration tools may surface old errors, all of which is behavioral context beyond the structured fields.

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

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

Three short sentences, front-loaded with the core action and its consumption semantics. The *CLS/preset detail is niche but earns its place by clarifying the tool's side-effect profile.

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 parameters and no output schema, the description carries the load well, covering the consumption side effect, the distinction from get_status, and the absence of *CLS/preset. Return format is unspecified, but for an error queue this is a minor 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?

The tool takes zero parameters, so the baseline is 4. There is no argument syntax to clarify, and the description appropriately spends its words on behavior instead.

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 and consume the instrument's error queue') with an explicit scope ('returning every recorded error'). It also distinguishes itself from the sibling get_status, so an agent can tell the two apart without opening either schema.

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 names the relevant alternative ('separate from status') and gives the condition that separates them ('reading removes the errors'), which tells the agent when to prefer this tool. It stops short of an explicit when-not-to-use rule, but the routing context is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds non-obvious behavior: page numbers are 1-based source-document pages rather than printed chapter labels, syntax and tables are preserved but diagrams are not reproduced, and the 1–5 page scope. It does not address truncation or error behavior for out-of-range pages.

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 tight sentences, front-loaded with the core action and scope, followed by format caveats. The final clause about 'exotic commands' is slightly tangential but still earns its place as a usage caution.

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 zero schema description coverage, the description supplies the critical missing context: return format (Markdown), page-numbering convention, and content fidelity (tables/syntax kept, diagrams omitted). Only the manual_id source and page_count behavior are unaddressed, which the sibling tools mostly imply.

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

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

Schema description coverage is 0%, so the description carries the burden, and it does clarify the key ambiguity — that 'page' refers to 1-based source-document pages, implicitly bounding the valid range. However, manual_id (how to obtain it, presumably via list_manuals) and page_count's default behavior are left to the schema and sibling context.

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 verb and resource (read source pages of original documentation) and states the scope (1–5 pages) and output form (Markdown). It does not explicitly differentiate itself from siblings such as search_manuals or list_manuals, though the distinction is largely inferable from the name.

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 guidance is a caution to verify model, option and firmware applicability before issuing a command found in the docs — useful but about downstream actions, not about when to call this tool. No mention of alternatives (search_manuals, list_manuals) or conditions for choosing this tool over them.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, and the description explains WHY: queries can consume state or start tests, so it is not universally read-only. It further discloses that no extra error query, preset, retry or RF change is injected, that unsupported queries may time out or raise -420, and that it is single-shot with no batching.

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 tool's role and consistently dense with constraints, with no filler sentences. The mid-sentence line breaks make it slightly harder to scan, but each clause carries a distinct rule, so little 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?

No output schema exists, and the description states the return shape (one ASCII response) as well as the limits and failure modes (timeouts, -420). Combined with the explicit transfer to block transport for binary payloads and to read_errors for error queries, an agent has everything needed to call this correctly.

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

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

Schema coverage is 0% (the lone 'command' property is an undocumented string), so the description must carry the parameter burden, and it does: one printable command, under 128 bytes, no semicolon batches, no newlines, no AR488 ++ commands. These are hard formatting and size constraints the schema does not express.

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?

Names the exact action (send one ASCII query, read one ASCII response) and immediately frames it as an 'expert escape hatch', which distinguishes it from the narrow siblings scpi_write, read_errors, and the manual-lookup tools. An agent can identify both the operation and its exceptional status without opening the schema.

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

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

Explicitly routes the agent: look the command up in the Markdown manuals first, use read_errors for querying errors separately, and use the driver's block transport instead of this tool for binary responses. It also names the condition under which the tool is appropriate (raw ASCII one-shot commands) versus when it is not.

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?

Far exceeds what the annotations convey (destructiveHint=true, readOnlyHint=false). It discloses side effects ('may change RF, erase data, reset or calibrate'), the safety posture ('No automatic RF mute, preset, error drain or retry is added'), and the meaning of success ('confirms transport completion only') plus the required follow-up (query and read_errors).

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-loads the purpose and identity, then layers constraints and cautions with no filler. Every clause adds a distinct, actionable rule.

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 raw-command escape hatch with one param and no output schema, everything an agent needs is present: scope, safety behavior, syntax limits, and the required post-execution verification step.

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

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

With 0% schema description coverage, the description carries full burden and compensates thoroughly: it constrains the command to a non-query, under 128 printable ASCII bytes, and forbids semicolon batches, newlines, AR488++ commands, and binary blocks.

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 ('send ONE ASCII non-query') and explicitly frames itself as an 'expert escape hatch.' The distinction from the sibling scpi_query is inherent: this is for non-queries, queries go elsewhere.

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 explicit when-to-use ('only within the user's requested work after checking the manual') and a clear alternative preference ('Prefer typed tools for supported procedures'), directing the agent to the typed siblings when they cover the procedure.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false and destructiveHint=false, so safety is covered. The description adds non-obvious matching behavior the annotations cannot convey: literal case-insensitive matching, whitespace normalization, and that results are short excerpts (implying truncation) with offset-based paging. It stops short of describing result ordering or a match-count cap.

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

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

Three short lines, front-loaded with the core purpose, then matching semantics, then routing. Every sentence carries information an agent would otherwise have to guess.

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?

No output schema exists, and the description does state the return shape (page references plus short excerpts). Read-only status is covered by annotations. The only gap is that manual_id and max_results are unexplained, which matters for a search tool that can be scoped to one manual.

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

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

Schema description coverage is 0%, so the description carries the burden. It characterizes the query well (literal, case-insensitive, whitespace-normalized, full spellings) and gestures at paging via 'next_offset', but never explains 'manual_id' scoping or 'max_results', leaving two of four parameters undocumented 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?

Specific verb+resource: 'Search original manual text offline' plus a clear statement of what comes back ('page references and short excerpts'). It also distinguishes itself from the sibling read_manual_pages and from list_manuals by scope, so an agent can route without opening a schema.

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?

Explicit routing guidance: 'Use next_offset for more matches, read_manual_pages for complete context' names the alternative and the condition that selects it. It also tells the agent how to phrase queries ('full command spellings (e.g. HICRest) or keywords, not only abbreviated SCPI'), which is a real usage constraint.

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?

Beyond the annotations (idempotent, non-destructive), the description discloses state side effects: RF on/off is preserved, and the tool will not silently switch modulation modes. That is meaningful behavioral context for a mutation, though it omits whether depth changes apply immediately or require an apply/commit step.

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 action and range, with side effects and the rejection case following. Three short sentences, no filler, though the final 'Does not silently switch modulation modes' sentence partially restates the preceding rejection clause.

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

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

For a single-parameter mutation with annotations covering safety and no output schema, the description covers purpose, valid input range, side effects, and the failure/alternative path. Minor gap: no statement of what happens on out-of-range input or whether the setting persists.

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

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

Schema coverage is 0% — the parameter is just a bare number. The description compensates by supplying both unit semantics (percentage) and the accepted range (0.1–100%), which is the key information an agent needs to invoke it correctly.

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 ('Change active analog AM path 1 depth') and supplies the valid range (0.1–100%). It also explicitly distinguishes itself from the sibling upload_am_wav by naming the modulation mode it refuses to operate on.

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 when-not rule ('Rejects I/Q voice playback') and routes the agent to the correct alternative (upload_am_wav). It does not, however, clarify how it relates to configure_am_tone or other AM siblings, so selection guidance is strong but not exhaustive.

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

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

The description discloses behavior far beyond the annotations: it preserves RF on/off and modulation, clears display offsets and reference modes, disables sweeps, enables automatic attenuation, mutes RF during the change, and warns that level_dbm is a generator setting under scaled I/Q. This is exactly the state-changing detail an agent 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?

The core purpose and ranges are front-loaded in the first sentence, with side effects following in short, dense sentences. Every clause carries operational information; nothing is 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 two-parameter setter with annotations covering the safety profile and no output schema, the description is nearly complete, covering ranges, state effects, and a scaled-I/Q caveat. It omits out-of-range error behavior and whether the call blocks during RF muting, which are minor gaps.

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

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

Schema coverage is 0%, so the description carries the full burden, and it delivers: usable ranges for frequency (250 kHz–4 GHz) and level (−135 to +20 dBm) are given for both parameters. It adds a semantic caveat for level_dbm, though it does not restate units or the exact meaning of frequency_hz beyond the implied Hz.

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?

It names a specific action (set a fixed carrier and level) with precise ranges, so the resource and scope are unmistakable. However, it never distinguishes itself from the sibling set_rf_output, leaving the agent to guess which of the two RF-setting tools applies.

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 through the operating ranges and the note that sweeping is disabled, which signals this is a static single-point setup. But there is no explicit when-to-use versus set_rf_output or scpi_write, nor any prerequisite or exclusion guidance.

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

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

Annotations already declare idempotent, non-destructive, non-read-only. The description adds real context beyond them: enabling reuses the current frequency/level/modulation, disabling preserves the waveform, and the call verifies the resulting enable state. It does not state what the verification returns or any hardware interlock 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?

Three short sentences, front-loaded with the action, then precondition, then side-effect note. No filler and each sentence carries distinct information.

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

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

For a one-parameter, no-output-schema tool this covers the essentials: action, precondition, state dependencies, and confirmation behavior. Only the exact form of the verified state/timing of the switch is unstated, which is minor.

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

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

Schema coverage is 0% and the single boolean 'enabled' is undocumented in the schema. The description compensates by making the boolean's meaning explicit (on/off) and explaining the state dependencies of each branch, which is more than the schema provides.

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: turning the RF OUTPUT enable state on or off, plus verifying that state. This is clearly distinct from tuning siblings like set_rf (frequency/level) or get_status (read-only inspection).

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 precondition: read status first when frequency, level, and modulation are unknown, which routes the agent to get_status. It does not name set_rf as an alternative or explain when RF output should be enabled versus left off, so it stops short of full when/when-not guidance.

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

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

Adds substantial context beyond annotations: verifies every uploaded byte, uses E443xB offset-14-bit big-endian format, turns RF/ARB OFF and leaves them off, may take minutes with a 900s timeout recommendation, and leaves partial files on failure with no retry or deletion. This richly complements the destructiveHint/openWorldHint annotations.

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

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

Front-loads the core action and follows with dense, relevant constraints. Nearly every sentence earns its place, though the sequence of constraints reads as a list rather than tightly organized 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?

For a mutation tool with no output schema, it covers input format requirements, side effects on RF/ARB, failure behavior, and the separate play_waveform step. An agent has enough to invoke it correctly and warn about recomputation costs.

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

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

Schema description coverage is 0%, so the description must carry the burden. It explains depth (fraction, 0.5 = 50% peak, range 0.001–0.99) and overwrite (set true for existing names), but says nothing about name or path semantics, leaving half the parameters undocumented.

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 (upload), resource (local mono 16-bit PCM WAV), and output form (conventional AM via separate I/Q files). It is clearly distinguishable from siblings like configure_am_tone and play_waveform, which it explicitly routes to.

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

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

Gives clear operational routing: 'Call play_waveform separately' and 'Existing names require overwrite=True'. It does not explicitly frame when to pick this over configure_am_tone, so it stops short of full when/when-not guidance, but context is clear.

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