RQM WaveEngine Jobs

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower; the description still adds genuinely useful context beyond them: no authentication required, the result is non-binding, and validation happens against the live catalog. It does not cover failure modes or what 'bounded' means in practice.

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 dense sentence that front-loads the action and packs scope, semantics (non-binding), and the auth constraint without 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 explained, and annotations cover the safety profile. However, with 0% schema coverage the description should do more to explain the required free-form 'request' object and the meaning of max_total_price, so the picture is only partially complete.

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

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

Schema description coverage is 0% across 3 parameters, including an opaque free-form 'request' object. The description only obliquely gestures at parameters ('bounded request' hints at max_total_price, 'live catalog' hints at capability_id) and never explains the request payload shape.

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?

Gives a specific verb+resource: validate a request against the catalog and return a price/duration estimate. The word 'estimate' clearly separates it from run_wave_job and run_buyer_job, though it never names a sibling explicitly.

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

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

The phrase 'non-binding price and duration estimate without authentication' implies this is a pre-flight check before committing to run_wave_job, but the description never states when to use it versus actually running the job. Usage is left 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 declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The description does add that only 'approved public' descriptors are returned, hinting at a visibility filter, but discloses nothing about auth needs, error behavior, or what 'approved' means. Modest added value over the 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?

One tightly scoped sentence with no filler and the key qualifier ('full approved public') front-loaded. It is arguably too terse rather than padded, so it scores well on efficiency without reaching the top band.

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. But for a simple lookup tool the description still omits how to obtain the required id and what 'approved public' excludes, leaving minor but real gaps.

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

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

Schema description coverage is 0% and the single required capability_id is undocumented in both schema and description. The description does not say what a capability_id looks like or where to obtain one (e.g., from list_wave_capabilities), so the agent is left to guess the identifier source and format.

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 verb (Return) and a resource (Wave capability descriptor), and 'one' plus 'full' implies it fetches a single complete record versus the list/search siblings. However, 'capability descriptor' is jargon and the description never pins down what such a descriptor contains or how it differs from get_wave_example, get_wave_receipt, etc.

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

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

No when-to-use guidance, no statement of prerequisites, and no routing to or away from alternatives. The only implicit signal is 'one', leaving the agent to infer that list_wave_capabilities/search_wave_capabilities are for browsing.

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, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is fully covered by structured data. The description contributes only that the example is singular ("one realistic illustrative") and includes a price guard, which is output content rather than behavior beyond the 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?

A single front-loaded sentence that leads with the verb and wastes no words. The comma-separated output list is dense but every item adds information; slightly listy rather than optimally structured.

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

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

An output schema exists, so return values need no explanation, and the description's enumeration of payload contents is a bonus. What remains missing — the semantics of capability_id and routing against run_wave_example — is a parameter/usage concern already scored above, not a completeness gap for a read-only lookup.

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 required parameter capability_id has 0% schema description coverage, so the description carries the full burden of explaining it — and it fails to mention capability_id at all. An agent cannot tell from the description that the example is scoped to a specific capability, or what values are valid.

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 verb ("Return") and enumerates the exact payload contents: request/result shape, artifact list, duration, price guard. An agent can tell what comes back, but the description never differentiates this from closely related siblings like run_wave_example or get_wave_capability, leaving the distinction 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?

There is no statement of when to use this tool versus run_wave_example (which presumably returns actual results) or get_wave_capability. The description reads as a pure output inventory with no usage context, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description does add one piece of behavioral context, 'principal-scoped,' implying access is limited to the calling principal, which is useful beyond the annotations, but it stops there.

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 short sentence with no waste and the resource is front-loaded after the verb. The compressed jargon ('principal-scoped bounded') trades a little clarity for brevity, keeping it just short of a 5.

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 rich annotations cover safety. What remains missing is any sense of how this differs from get_wave_job_result or get_wave_receipt and any parameter context, which is the minimum an agent needs for a 4-parameter required-argument call.

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

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

Schema description coverage is 0% across four required parameters, so the description carries the full burden of explaining them. Instead it says nothing about job_id, artifact_id, product, or schema_version, leaving the agent to infer their meaning from const values and regex patterns alone.

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

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

The description gives a clear verb ('Retrieve') and a resource ('Wave result artifact'), so the basic operation is identifiable. However, the qualifiers 'principal-scoped' and 'bounded' are opaque, and it never distinguishes an 'artifact' from the sibling tools get_wave_job_result or get_wave_receipt, leaving the agent unable to tell which of these job-scoped reads it should call.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. With siblings like get_wave_job_result, get_wave_job_status, and get_wave_receipt in the same family, the absence of 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds the useful constraint that only settled results are returned, but says nothing about error behavior for in-flight jobs, auth needs, or latency - with annotations carrying the safety profile, 3 is appropriate.

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 tight sentence with no wasted words and the key state constraint front-loaded. It is arguably too terse for a tool with a polymorphic input schema, which keeps it from a 5.

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 annotations cover safety. However, the input schema is a three-branch anyOf with schema_version constants and a product enum, and the description offers no guidance on which reference form to supply - a gap for this level of input complexity.

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

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

Effective parameter count is 0 (the anyOf schema is self-describing with const/enum values) and schema description coverage is 100%, so the baseline is 4. The description adds nothing about job_id/product/schema_version semantics, but the schema fully documents them.

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 ('Read') and resource ('product result') and adds a meaningful scope qualifier ('one completed and already-settled'). However, it never distinguishes itself from close siblings like get_wave_job_status or get_wave_job_artifact, 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?

The phrase 'completed and already-settled' implies the precondition for calling this tool (the job must be finished), which is implied usage rather than explicit guidance. No alternatives are named and no when-not-to-use condition is 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description's only added behavioral context is the 'authorized' access constraint and the scope (Wave/Studio managed-simulator jobs); it says nothing about job states, error behavior, or what 'status' encompasses.

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 for a simple read tool. It is arguably too terse for the ambiguity it leaves, but nothing in it 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-value explanation is not needed, and annotations cover the safety contract. The remaining gap is disambiguation from the cluster of sibling retrieval tools, which the description does not address for an agent selecting among ~35 related 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% and the anyOf variants already encode the job_id/product/schema_version contract, so the schema does the heavy lifting. The description adds no parameter detail (e.g., that 'Studio' maps to the 'quantum' product enum value), leaving the naming mismatch unexplained.

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 clear verb ('Read') and a specific resource ('one authorized Wave or Studio managed-simulator job'), so an agent knows it retrieves a single job. However, it never states that what comes back is *status* (the meaning the tool name carries) and does not distinguish itself from siblings like get_wave_job_result, get_wave_job_artifact, or get_wave_receipt.

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

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

There is no guidance on when to call this versus the other job-retrieval siblings (get_wave_job_result, get_wave_job_artifact, get_wave_receipt), and no stated preconditions beyond the word 'authorized'. The agent is left to infer the selection criteria entirely.

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, idempotentHint, destructiveHint=false, and closed-world, so safety and repeatability are covered without the description. The description still contributes useful behavior by labeling the receipt 'durable' and tied to a 'settled' reservation, signalling finality, but says nothing about availability lag, retention, or error 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?

A single front-loaded sentence with no wasted words, which is appropriate for a narrowly scoped getter. It is close to optimally tight, though the terseness leaves the semantic gaps noted in other dimensions unaddressed.

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-value explanation is not required, and annotations cover the read-only/idempotent profile. What remains under-specified is the unexplained 'Account Core' jargon and the absence of any precondition or failure description for a two-required-parameter call.

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

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

Schema description coverage is 0% for two required parameters, so the description is the only place meaning could be added, and it does not mention reservation_id or schema_version at all. The only implicit signal is that a single reservation is addressed, which does not compensate for the gap.

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

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

The description states a specific verb ('Retrieve') plus a concrete resource ('durable Account Core receipt') scoped to 'one settled WaveEngine reservation'. That is clearly distinguishable from generic job-result siblings, though it never names the neighboring tool (e.g. get_wave_job_result) it should be preferred over, so it stops short of a 5.

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

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

The phrase 'one settled WaveEngine reservation' implies a precondition (the reservation must have settled) and a one-at-a-time cardinality. However, there is no explicit when-to-use versus alternatives such as get_wave_job_status, get_wave_job_result, or get_wave_job_artifact, so the routing guidance is only implied.

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, idempotentHint, destructiveHint=false and closed-world behavior, so the safety profile is covered. The description adds no further behavioral context — no pagination, filtering, or result-size behavior — and instead makes an opaque completeness claim ('exact 20/20/20') that the agent cannot verify or act on.

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, reasonably short sentence with no filler padding, which is appropriate in size. However, it front-loads cryptic jargon ('20/20/20 RQM specialist work portfolio') rather than the plain purpose, so the sentence does not fully earn 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, but with three undocumented parameters at 0% coverage and an ambiguous description of what is actually returned, the definition is not complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 0% and the description never mentions product, surface, or schema_version. The two enums (product, surface) and the fixed schema_version const are left entirely unexplained, so the description does nothing to compensate for the coverage gap.

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

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

The name and title say 'list buyer jobs', but the description instead promises 'complete agent discovery contracts and readiness for the exact 20/20/20 RQM specialist work portfolio' — a phrase that never names the resource being listed and reads as internal jargon. An agent cannot confidently distinguish this from siblings like search_buyer_jobs or list_capabilities based on this text.

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

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

There is no statement of when to call this rather than search_buyer_jobs, list_capabilities, or run_buyer_job, and no prerequisites or exclusions. Usage must be inferred entirely from the name.

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 the full safety profile (readOnlyHint, idempotentHint, destructiveHint, openWorldHint), so the description need not restate them; however, it adds almost nothing behavioral beyond the vague 'preserved' vs 'dynamic' distinction. It does not say what determines which catalog is returned, whether results are paged, or how the filters 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?

A single front-loaded sentence with no wasted filler, so length is fine. However, the brevity is under-specification rather than economy: the one sentence spends its words on jargon that does not resolve the agent's decision.

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 an output schema present, return values need not be described, but the input side is bare: four undocumented parameters and an ambiguous routing relationship to search_wave_capabilities. For a catalog-listing tool with zero required parameters and rich filter surface, the description leaves the agent without enough to invoke 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 0%, so four parameters (surface, category, maximum_price, maximum_duration_ms) carry no documentation in the structured data. The description mentions 'surface' only in passing and never maps to the four enum values, nor explains the category, price, or duration filters at all, so it does not compensate for the coverage gap.

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

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

The description names a resource (the v0/v1 surface or v2/v3 Wave catalog) and implies a listing/describing action, but the terminology is internal jargon ('preserved', 'dynamic v2/v3 Wave catalog') that an agent cannot decode without domain context. It also fails to distinguish itself from the sibling search_wave_capabilities, which reads as performing an overlapping job.

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 'or' hints that two catalog variants exist, but there is no explicit when-to-use guidance, no mention of when to pick this over search_wave_capabilities, and no stated prerequisites or exclusions. The agent is left to infer routing purely from the name.

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 non-read-only, idempotent, non-destructive, closed-world. The description adds meaningful behavior beyond that: this is a three-phase flow that actually settles payment (spends funds), which is critical context the annotations' destructiveHint=false could otherwise obscure. It still omits what happens on partial failure across quote/settle/submit and whether errors are recoverable.

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 tight sentence that front-loads the three phases and then the target resource. 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?

Output schema exists, so return values need not be described. But for a six-required-parameter, payment-settling, composite tool with an opaque request object, the definition leaves too much unexplained: no parameter meaning, no ordering between quote/settle/submit, and no routing against the many competing siblings.

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 six required parameters, and the description adds no meaning for any of them. In particular max_total_price (the spend cap), capability_id (allowlisted capability selector), idempotency_key, and the free-form request object are given no semantics in either place.

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 composite action set (quote, settle, submit) on a concrete resource (one allowlisted WaveEngine/Studio/Robotics buyer job) via x402. An agent can tell it is the end-to-end job runner, but the jargon 'allowlisted' and 'x402' and the overlap with sibling quote_job / submit_wave_job / submit_quantum_job are not resolved.

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 tool overlaps heavily with quote_job (quote only), submit_wave_job and submit_quantum_job (product-specific submit), yet the description never says when to prefer this composite runner over those narrower siblings, nor what prerequisites (allowlisting, funding session) must exist first.

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 readOnly/idempotent/closed-world/non-destructive, so the safety profile is covered. The description adds genuine context beyond that: this performs real execution through a typed adapter (not a mock or dry run) yet is constrained to a fixed catalog-owned example with no arbitrary input, which is exactly the kind of nuance 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?

A single front-loaded sentence with the action verb first and no padding. It is denser and more jargon-laden than ideal ('real typed WaveEngine adapter'), but every clause carries meaning and 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. With one simple required parameter and the bounded-execution behavior explained, the definition is nearly complete; the only real gap is what capability_id actually denotes.

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 schema only supplies the name, type and length bounds of the single capability_id parameter. The description hints the value is catalog-owned but never explains that capability_id selects a catalog capability or gives format/valid-value guidance, so it does not compensate for the coverage gap.

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

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

States a specific verb ('Execute') and resource ('catalog-owned bounded example') and clarifies the execution route ('through the real typed WaveEngine adapter'). It partially distinguishes itself from siblings by emphasizing 'bounded' and 'without accepting arbitrary input', but never explicitly names get_wave_example or run_wave_job as alternatives, so the contrast remains inferential.

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

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

The phrase 'without accepting arbitrary input' implies a contrast with tools that do (e.g. run_wave_job), and 'bounded example' implies use only for fixed catalog examples. However, no explicit when-to-use/when-not or named alternative is given, leaving usage 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 declare idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the description's 'idempotent' restates structured data rather than adding it. It does add the default-payment behavior (anonymous x402 vs authenticated balance), which is useful context beyond annotations, but omits the price cap, runtime bounds, and artifact 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?

One sentence, front-loaded with the payment decision and ending on the action. No filler, though it is arguably too terse given the parameter surface it must cover.

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. But for an 8-parameter, 4-required, nested-object job submission tool with 0% schema description coverage, the description leaves most invocation-critical fields (price ceiling, runtime limit, artifact preferences, request payload shape) unexplained.

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

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

Schema description coverage is 0% across 8 parameters, so the description carries the full burden. It explains only payment_rail's two modes and echoes idempotency; capability_id, request, schema_version, max_total_price, artifact_preferences, and maximum_runtime_seconds get no meaning beyond their names and patterns.

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: 'submit one idempotent WaveEngine job', with a clear payment-scope statement. It does not name the adjacent siblings (estimate_wave_job, run_buyer_job, run_wave_example), so an agent must infer the distinction, but the core 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?

'By default' vs 'or explicitly use' gives real guidance on the payment_rail choice, which is the main branching decision. However, there is no guidance on when to run versus estimate first, or when this is preferred over run_buyer_job / run_wave_example.

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 readOnly/idempotent/non-destructive, so safety is covered. The description adds one genuine behavioral trait beyond that: retrieval is 'deterministic semantic scoring' over 'instructions, examples, outputs, and next steps.' It does not disclose ranking guarantees, tie-breaking, or how limit interacts with scoring.

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 filler. It is dense but efficient; the mild cost is that compactness comes at the expense of the parameter detail an agent actually needs.

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 5-parameter search tool with 0% schema coverage the description leaves key inputs (surface, product) and their effect undocumented. An agent cannot determine how to scope a query from this definition alone.

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% across 5 parameters, so the description carries the full explanatory burden and fails to meet it. It never explains 'surface' (buyer_job/implementation_capability/research_evidence/all), 'product', 'limit', or 'schema_version' – the single most consequential parameter, 'surface', is completely 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+resource: 'Select RQM buyer jobs ... using deterministic semantic scoring.' An agent can tell it is a relevance-search tool, distinct from list_buyer_jobs by implication of scoring rather than enumeration. However, it never names the sibling it competes with, and 'from work-language requests' is jargon that blurs the actual input.

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

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

No explicit when-to-use or when-not guidance. The obvious alternative, list_buyer_jobs, is never mentioned, nor is the condition (semantic/ranked retrieval vs. plain enumeration) that would select this tool. Usage is only inferable from the phrase 'semantic scoring.'

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, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only 'Deterministically rank,' which tells the agent the ordering is stable, but says nothing about result shape, scoring basis, or filter failure behavior. With annotations doing the heavy lifting, this is a moderate contribution.

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 or redundancy. It is well-structured, though its brevity reflects under-specification rather than disciplined economy.

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 8-parameter tool with an output schema but zero schema description coverage needs more than one sentence. The description omits parameter meanings, the filter/surface semantics, and any note that this is a read-only catalog search, so an agent cannot invoke it confidently without guessing at the filters.

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 burden falls on the description, yet it only gestures at 'natural-language task' (query) and 'bounded filters' without explaining limit, surface enum values and default, category, input_format, maximum_price (with its unusual 6-decimal pattern), maximum_duration_ms, or required_artifact_media_type.

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 ('rank') and resource ('WaveEngine capabilities') plus the input modality (natural-language task). However, it offers no differentiation from the sibling list_wave_capabilities, leaving the agent to infer which of the two to call.

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

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

The phrase 'for a natural-language task and bounded filters' hints at the intended input shape, but there is no explicit when-to-use, when-not-to-use, or alternative routing (e.g., vs list_wave_capabilities or get_wave_capability).

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, idempotentHint=true, and destructiveHint=false, so safety and idempotency are covered. The description adds genuinely new constraints ('Bounded signal processing only; 2 channels; 1024 samples/channel'), but says nothing about reversibility, permissions, or what happens to the original capture. Adds real value but not rich behavioral context.

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

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

The Problem/Input/Result/Limits layout is compact and front-loads the core purpose. Each phrase is load-bearing; there is no filler, though the terse labels read more like notes than 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 described, and the description does supply input and limit context. But with nested objects, 0% schema coverage, and four required parameters, the definition is incomplete on parameter and usage guidance for a fairly complex 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 0%, so the description must carry parameter meaning. It names nested request fields (sample rate hz, channels, angle radians, assertions) but entirely omits the top-level required parameters schema_version, idempotency_key, and max_total_price, and the listed names do not match the actual schema properties, leaving key inputs 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?

The description names a specific verb+resource ('apply this bounded phase correction and verify the supplied preservation assertions'), so an agent knows exactly what operation runs. However, it offers no differentiation from close siblings like wave_measure_phase_drift_v1 or wave_rotate_and_validate_two_channel_frame_v1, so the agent must infer which phase tool is correct.

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 guidance and no mention of alternative tools. The 'Limits' line implies applicability (bounded processing, 2 channels, 1024 samples) but never states the conditions that select this tool over 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?

Annotations indicate this is not read-only and is idempotent, but the description doesn't explain what happens to pipelines or fixtures, whether it mutates state, or what the tolerance checks entail. For a non-read-only tool, this is a significant gap. The 'Limits' portion mentions channel and sample bounds, which is helpful but not enough.

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 attempts a structured format (Problem/Input/Result/Limits) but the 'Input' section is truncated ('maximum absolute....') and overly terse. It's not excessively long, but the structure is not well-executed.

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 an output schema present, return values needn't be explained, but the description omits critical context about the request format, the meaning of 'caller tolerances', and how to interpret tolerance checks. For a tool with 4 required parameters and nested objects, this is insufficient.

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%, and the description only vaguely references 'JSON with left pipeline, right pipeline, fixture, maximum rmse, maximum absolute...' without mapping to the actual parameters (schema_version, request, idempotency_key, max_total_price). The parameter names in the schema are not reflected in the description, leaving the agent to infer structure from nested objects.

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 verb+resource ('Compare these two supported Wave pipelines on the supplied fixture') which is reasonably clear. However, the added context about caller tolerances and the 'Problem/Input/Result/Limits' framing is a bit disjointed and doesn't clearly distinguish it from wave_compare_waveform_captures_v1 or wave_verify_wave_pipeline_v1, which sound similar.

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

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

No guidance on when to use this tool versus alternatives like wave_compare_waveform_captures_v1 or wave_verify_wave_pipeline_v1. The description mentions 'supported Wave pipelines' and 'caller tolerances' but doesn't specify the conditions under which an agent should select 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?

Annotations declare it is idempotent, non-destructive, non-open-world, and not read-only (consistent with a paid 'buyer-job' tool that charges max_total_price). The description adds genuinely useful behavioral context beyond annotations: bounded signal processing only, exactly 2 channels, and a 1024 samples/channel cap, which tells the agent the operating envelope.

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?

Uses a tight Problem/Input/Result/Limits layout that front-loads the operation and then supplies the constraints. Every clause carries information; it is only slightly under-structured for the wrapper parameters.

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 spelled out, and the description covers the core input fields, result nature, and hard limits. However, for a job-based tool that charges a fixed price, it omits any explanation of idempotency_key or max_total_price semantics, which an agent invoking it ought to understand.

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% and the real inputs are hidden inside a free-form 'request' object, so the schema explains almost nothing. The description compensates by naming the request contents (sample rate hz, channels, reference channel id, candidate channel id, rules), but it says nothing about schema_version, idempotency_key, or the meaning of max_total_price, leaving the wrapper params opaque.

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 ('Compare') and resource ('these two bounded waveforms against the supplied alignment and numeric rules'), plus the result ('waveform differences and caller-rule results'). This differentiates it from wave_compare_pipeline_responses_v1 by scoping to two bounded waveform captures, though it never names the sibling explicitly.

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

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

The 'Problem:' framing describes what the tool addresses, which implies its use case, but there is no explicit when-to-use/when-not-to-use guidance and no mention of alternatives like wave_compare_pipeline_responses_v1 or wave_validate_reconstruction_quality_v1. An agent must infer selection from the description 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?

Annotations already declare idempotentHint=true, destructiveHint=false and readOnlyHint=false, so safety/idempotency is covered. The description usefully adds operating limits (bounded signal processing, 8 channels, 4096 samples/channel), but omits that this appears to be a paid/bounded-cost job (max_total_price) and says nothing about auth or failure behavior.

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

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

It is short and labeled (Problem/Input/Result/Limits) but redundant — 'validated pipeline and execution trace' is repeated in both the Problem and Result lines, and the labeled format pads rather than front-loads the key constraint.

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, but for a 4-required-param nested-object tool at 0% schema coverage the description leaves critical fields (idempotency_key, max_total_price, schema_version) unexplained and mismatches its own param list to the real schema.

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% and all four top-level parameters are required, yet the description mentions only 'fixture' and 'maximum round trip rmse', which do not correspond to the required schema fields (schema_version, request, idempotency_key, max_total_price). The required idempotency_key and the monetary max_total_price const are never explained.

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 (compile a curated processing recipe) and names the outputs (validated pipeline and execution trace), which is more than the title alone. It does not distinguish itself from similar siblings such as wave_optimize_processing_pipeline_v1 or wave_verify_wave_pipeline_v1, so an agent cannot easily tell which to pick.

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 guidance and names no alternatives or prerequisites. With ~30 sibling wave_* tools, the absence of any selection criteria 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?

Annotations already declare the mutation/idempotency/safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds genuinely useful behavioral context beyond that: the output is checksummed with declared normalization, and processing is bounded to 8 channels and 4096 samples per channel.

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 Problem/Input/Result/Limits structure front-loads the action and is easy to scan with no filler sentences. It is efficient, though the terse phrasing borders on cryptic at points.

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 limits section covers operational constraints. However, for a 4-param tool with nested objects and 0% schema coverage, two required wrapper parameters (idempotency_key, max_total_price) and their roles are left entirely to the schema.

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% and the schema is an opaque wrapper (arbitrary nested 'request' object plus schema_version const, idempotency_key, max_total_price), so the description must compensate. It names three meaningful payload fields (sample rate hz, channel, normalization) inside 'request', but says nothing about idempotency_key, max_total_price, or the schema_version const — only partial compensation for the coverage gap.

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

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

States a specific verb and resource — converting a bounded complex capture into a checksummed spectral artifact — and names the salient output attributes (normalization, checksums). It reads clearly against spectral siblings like wave_validate_spectral_criteria, though it never explicitly distinguishes itself from them by 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?

'Bounded signal processing only; 8 channels; 4096 samples/channel' gives boundary conditions that imply when the tool is applicable, but no alternative tool is named and no explicit when-not or alternative-selection guidance is provided. Usage is implied rather than 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so safety is partly covered. The description adds useful hard limits (bounded signal processing, 8 channels, 1024 samples/channel) that are not in the annotations, but says nothing about cost implications (max_total_price) or how the result is produced.

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 Problem/Input/Result/Limits labeling is efficient and easy to scan, with no filler sentences. Front-loading is good, though the individual clauses are dense with undefined jargon.

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 limits are stated. But for a job submission with four required params, nested objects, and 0% schema coverage, the parameter mismatch and absence of usage guidance leave the agent under-equipped.

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

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

Schema description coverage is 0%, so the description must compensate. It claims the input is 'JSON with sample rate hz, channels', which does not match the required top-level fields (schema_version, request, idempotency_key, max_total_price) and leaves the schema_version const and max_total_price const entirely unexplained.

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 'diagnose' and resource 'coordinated complex capture' are present, and it gestures at a distinguishing scope ('without inferring a physical cause'). However, 'bounded Wave-Intelligence degradation findings' is opaque jargon, so an agent cannot confidently distinguish this from siblings like wave_validate_reconstruction_quality_v1 or wave_measure_phase_drift_v1.

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 named alternative among the many wave_* siblings. The only guidance is the implicit constraint 'without inferring a physical cause', which is a scoping note rather than a routing rule.

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 idempotentHint=true and destructiveHint=false, so the description's job is supplemental. It adds genuine behavioral context the annotations lack: the operation is bounded signal processing, capped at 4 channels and 1024 samples/channel, and it returns both a fitted equalizer and pilot-fit evidence. Missing are details on failure/auth behavior for what is a compute-style job.

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 Problem/Input/Result/Limits structure is front-loaded and dense, with zero filler sentences. Every clause carries actionable 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 bounded computation tool with an output schema already present, the description supplies the problem statement, required payload keys, expected result, and numeric limits. Only the semantics of the three housekeeping parameters remain unexplained.

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

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

Schema description coverage is 0% and the schema is opaque (an untyped `request` object plus three fixed housekeeping fields), so the description has to carry the load. It partially does by enumerating the payload keys (input channels, output channels, received, desired, pilot mask), but it never explains schema_version, idempotency_key, or max_total_price, leaving real gaps.

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 algorithm-resource pair ('Fit a bounded quaternion NLMS equalizer') plus the exact input domain ('received and desired pilot capture'), so an agent can distinguish it from generic fit tools like wave_fit_coupled_channel_model_v1 without opening a schema. It stops short of explicitly naming the sibling alternative it should be preferred over.

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 'Limits' line gives hard constraints (bounded signal processing, 4 channels, 1024 samples/channel), which is useful, but there is no statement of when to choose this over sibling tools such as wave_fit_coupled_channel_model_v1 or wave_optimize_processing_pipeline_v1, and no preconditions or 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 idempotentHint=true, destructiveHint=false, and readOnlyHint=false, so the safety profile is covered. The description adds bounded-processing limits (8 channels, 1024 samples) which is useful, but it says nothing about the job-submission/cost behavior implied by the max_total_price and idempotency_key parameters.

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?

Clean Problem/Input/Result/Limits structure with no wasted words and the purpose front-loaded. Efficient for its size, though the terse bullets substitute brevity for detail.

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 limits add context. However, with nested request objects, 0% schema description coverage, and cost/idempotency parameters unexplained, the description is only partially complete for a job-submission 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 0% across 4 required parameters. The description only gestures at 'JSON with sample rate hz, channels' inside the request payload and never explains the required schema_version, idempotency_key, or max_total_price fields, leaving most parameter semantics 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 (Convert/Extract) and resource (coordinated complex capture → versioned Wave-Intelligence feature vector), so the core operation is identifiable. It does not differentiate itself from siblings such as wave_convert_capture_to_spectrum_v1, and 'Wave-Intelligence feature vector' is jargon-heavy, but the purpose is clear enough to distinguish the action type.

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 'Problem:' framing implies when the tool applies (converting a complex capture to a feature vector), but no explicit when-to-use, when-not, or named alternatives against the many sibling wave_* tools are given. Usage is implied rather than guided.

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, idempotentHint=true, destructiveHint=false, so the mutation/repeatability profile is covered. The description usefully adds the input domain limits and states the result shape (model plus fit evidence), but omits cost/auth context despite the const max_total_price of 0.005000 implying a paid job.

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 Problem/Input/Result/Limits format is front-loaded and efficient, with the core operation stated first. No wasted sentences, though the terse label style sacrifices some clarity.

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

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

An output schema exists, so return values need not be explained, and the description covers input composition and limits. But for a 4-param, nested-object, paid job at 0% schema coverage, it leaves gaps around the wrapper parameters and cost/auth expectations.

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% with 4 params, so the description must carry the burden. It partially does by specifying that the request JSON holds feature count, output count, features, and targets, but the other required fields (schema_version, idempotency_key, max_total_price) get no semantic explanation.

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

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

The description names a specific verb (Fit) and a concrete resource (a bounded structured quaternion ridge model over coupled channel features/targets), which is distinguishable from siblings like extract_wave_features or optimize_processing_pipeline. However, the jargon ('structured quaternion ridge') and lack of explicit sibling comparison keep 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?

No statement of when to use this tool versus the many other wave_* fitting/processing siblings, and no prerequisites or exclusions. The 'Limits' line gives operating constraints (bounded signal processing, 16 channels, 512 samples/channel) but that is scoping, not usage guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description usefully adds hard bounds (8 channels, 1024 samples/channel) and the accept/reject decision behavior plus checksummed artifacts, but says nothing about failure modes, cost semantics, or what happens when rules are violated.

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 Problem/Input/Result/Limits framing front-loads the gating purpose and scans quickly with no filler. It is appropriately sized for a mid-complexity 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 no elaboration, and annotations carry the safety profile. However, with nested request objects, 0% parameter coverage, and a const-bound max_total_price, the definition is only partially complete for correct invocation.

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% across 4 required parameters (schema_version, request, idempotency_key, max_total_price). The description hints at request contents (sample rate hz, channels, rules) but leaves three top-level parameters entirely unexplained, which is a meaningful gap at this complexity.

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+outcome (accept or reject a bounded signal capture against caller-supplied metric rules) and the resource being gated. It is distinguishable from siblings like wave_validate_spectral_criteria_v1 or wave_diagnose_multichannel_capture_v1, though it does not name a sibling to sharpen the distinction.

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

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

The description never states when to choose this gate over sibling validators, nor any preconditions. 'Limits: Bounded signal processing only' is a capability constraint, not usage guidance, so the agent is left to infer the selection criteria.

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 cover safety and idempotency: readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=false. The description adds useful operational constraints beyond annotations: bounded signal processing only, 8 channels maximum, and 16384 samples per channel. It does not explain failure behavior or authorization, but it meaningfully extends the annotation profile.

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

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

The description is short and structured with Problem, Input, Result, and Limits sections. It is front-loaded and wastes little space, though the Input line is too vague to be useful.

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

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

The tool has four required parameters, a nested request object, 0% schema description coverage, and a paid-job constraint implied by max_total_price. The description covers output evidence and signal limits, but omits required input fields, idempotency behavior, and pricing semantics, leaving key invocation details absent.

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% and there are four required parameters, including idempotency_key, max_total_price, schema_version, and a nested request object. The description says only 'Input: JSON with fixture,' which does not explain any of the actual required fields and does not compensate for the complete lack of schema descriptions.

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

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

The description states a specific verb and resource: generate a bounded sine or safe-formula signal fixture and return reproducibility, measurement, checksum, and validation evidence. This is clear enough to distinguish it from most sibling wave-processing tools, though it does not explicitly compare itself to alternatives such as reconstruct_bounded_capture or run_wave_job.

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 guidance, no prerequisites, and no named alternatives. It only describes the tool's problem, input, result, and limits, leaving the agent to infer when this fixture-generation tool is preferable to 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?

Annotations already declare idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds real behavioral bounds not present in the schema ('bounded signal processing only; 8 channels; 4096 samples/channel') and says the result is 'measurements and tolerance checks', but it never mentions the paid job dispatch behavior implied by the required max_total_price field and readOnlyHint=false.

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 Problem/Input/Result/Limits structure is front-loaded and each section earns its place with no filler. The only blemish is the truncated 'maximum rms....' which reads as an unfinished edit rather than a deliberate omission.

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-value detail is not required, and the description does cover purpose, limits, and result type. However, for a nested-object tool with 4 required envelope parameters at 0% schema coverage, the absence of selection guidance against many similar wave_* siblings and any note on the job/pricing envelope leaves meaningful gaps.

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

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

Schema description coverage is 0% and the inner 'request' object is fully opaque (additionalProperties only), so the description carries the burden. It names several payload fields ('reference, observation, maximum absolute drift radians, maximum rms') but trails off with '....' and says nothing about schema_version, idempotency_key, or max_total_price, leaving the envelope parameters unexplained.

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 ('measure phase drift') and scopes it ('in this bounded complex observation against the supplied reference and tolerances'), which separates it from sibling wave_* tools that transform, reconstruct, or validate rather than measure. It stops short of explicitly naming which sibling to use instead, 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?

There is no when-to-use guidance and no mention of alternatives, despite ~30 sibling tools including wave_apply_verified_phase_correction_v1 and wave_validate_spectral_criteria_v1 that an agent could easily confuse with this one. The 'Problem/Input/Result/Limits' framing describes the tool but never routes the caller.

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 declare readOnlyHint=false, idempotentHint=true and destructiveHint=false, and the description adds genuinely useful material beyond them: the hard operating limits (bounded signal processing, 8 channels, 4096 samples/channel). However it never explains the non-read-only nature of the call, cost implications of max_total_price, or idempotency-key behavior, so it leaves behavior partially undisclosed.

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

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

The Problem/Input/Result/Limits layout is compact and front-loads the purpose, but the truncated '....' and run-on field list make it read like clipped boilerplate rather than a deliberately structured description.

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 restated, and the description does cover problem, inputs, result and operating limits. Still missing are the cost/pricing model, idempotency semantics, and whether this is a synchronous call or a job submission, which matters for a mutation-flagged tool in a job-oriented sibling set.

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% and the request object is opaque (free-form additionalProperties), so the description's enumeration of request internals (operations, fixture, objective, maximum operations, maximum equivalence) is real added value. But the three other required top-level parameters (schema_version, idempotency_key, max_total_price) are never explained, and the trailing '....' suggests the list is truncated.

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 ('Optimize this supported Wave pipeline') plus the optimization target ('operation-count objective and equivalence rule'), and it lists what comes in and out. It distinguishes itself loosely from verification siblings like wave_verify_wave_pipeline_v1 by framing itself as optimization, though it never names the alternative 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, no prerequisites, and no mention of alternatives such as wave_verify_wave_pipeline_v1 or run_wave_job. The 'supported Wave pipeline' phrasing implies a precondition but never states it, leaving selection 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?

Annotations already declare the safety profile (not read-only, idempotent, not destructive, closed-world). The description adds useful operational limits (bounded signal processing, 8 channels, 4096 samples/channel) and states the result form, but is silent on cost/authorization even though the schema fixes max_total_price, so an agent gets no hint that this is a priced job submission.

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 Problem/Input/Result/Limits labeling is well structured and front-loaded, but the Input sentence is visibly truncated ('maximum....'), which costs clarity and wastes the section that most needs completeness.

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, but the input is an opaque nested 'request' object with 0% schema coverage and four required fields, two of which (idempotency_key, max_total_price) are never addressed. For a job-submission tool with fixed pricing and a generic request envelope, the definition is materially 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 coverage is 0% and the description lists request-internal fields (observation, reference, assumed transfer, maximum rmse) but truncates mid-list ('maximum....'). The three other required top-level parameters (schema_version, idempotency_key, max_total_price) receive no explanation at all, so the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource: reconstruct a 'bounded capture' under a transfer assumption and verify against reference rules. 'Bounded' plus the limits line distinguishes it somewhat from the vaguer sibling wave_reconstruct_time_domain_signal_v1, though it never names that sibling or states the boundary explicitly.

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

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

No when-to-use or when-not-to-use guidance. There is no mention of how this differs from siblings like wave_reconstruct_time_domain_signal_v1 or wave_validate_reconstruction_quality_v1, leaving selection to inference from the word 'bounded'.

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 cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the description must add operational context – and it does. It discloses that processing is bounded, that limits are 8 channels and 4096 samples/channel, and that a round-trip rule is verified, all useful traits beyond the annotations. It does not mention auth needs or cost despite a max_total_price parameter, keeping it from 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?

The Problem/Input/Result/Limits structure is front-loaded and each line earns its place by stating purpose, payload fields, output, and bounds. It is appropriately sized with no filler. Minor redundancy between 'Problem' and 'Result' keeps it from a 5.

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 purpose, key input fields, and bounds. But for a tool with deeply nested, undocumented request objects and a 0% schema coverage, listing only four field names leaves an agent guessing at the full request shape. Adequate but incomplete for correct invocation.

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% across 4 required parameters, so the description must carry the load. It names relevant request fields (sample rate hz, frequency bins, normalization, rules), which meaningfully documents the nested payload. However it says nothing about the top-level idempotency_key, max_total_price, or schema_version semantics, leaving a real gap.

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

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

The description gives a specific verb+resource: 'Convert these bounded frequency bins into time-domain samples' plus an additional round-trip verification step. This is clearer than a name restatement and an agent understands the core operation. It stops short of distinguishing clearly from close siblings such as wave_reconstruct_bounded_capture_v1 or wave_validate_reconstruction_quality_v1, so it lands at 4.

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 frames the operation as a 'Problem' and lists limits, but never states when to choose this tool over the many similar wave siblings or what prerequisites apply. No exclusions or alternative routing are provided. Usage is only weakly implied by the problem framing.

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, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the mutation/safety profile is covered. The description adds useful bounds (8 channels, 4096 samples/channel, bounded signal processing) and the invariant-validation behavior, but says nothing about failure handling or what a rejected invariant implies. It adds some value without contradicting the 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?

Four compact labeled sentences (Problem / Input / Result / Limits) with the problem statement front-loaded and no filler. Efficient, though the terse labels are slightly telegraphic rather than flowing 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 needn't be described, and the description does cover the operation, its inputs and its limits. However, for a 4-parameter mutation tool with 0% schema description coverage, the opaque envelope (schema_version, idempotency_key, max_total_price) leaves a real gap an agent must resolve elsewhere.

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% across 4 required parameters, so the description carries full burden. It names payload contents ('channels, rotor, rules') which partially maps to the freeform 'request' object, but the mandatory envelope parameters schema_version, idempotency_key, and max_total_price are not explained 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 states a specific verb and resource: 'Rotate these two coordinated complex channels with the supplied rotor and validate caller invariants', plus a result statement. This tells an agent exactly what the operation does, though it does not explicitly differentiate itself from related wave_* siblings like wave_apply_verified_phase_correction_v1 or wave_transport_polarization_frame_v1.

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 named alternative among the many sibling tools. The 'Problem:'/'Limits:' framing reads as a spec rather than invocation routing, leaving the agent to infer 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?

Annotations already declare this mutates (readOnlyHint=false) but is idempotent, non-destructive, and closed-world, so the safety profile is covered structurally. The description adds the bounded-processing limits and the fact that invariant checks are returned, which is useful context, but it says nothing about cost, authorization, or how the job is submitted.

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 Problem/Input/Result/Limits structure is tight, front-loaded, and easy to scan, with no filler sentences. It is slightly terse on the request payload, 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?

An output schema exists so return values need not be detailed, and the annotations carry the safety profile, but for a tool with 4 required parameters and 0% schema coverage on a nested free-form request, the description leaves the actual call shape underspecified. It is adequate but not complete for correct invocation.

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% and all 4 top-level parameters are undocumented. The description names two request-payload fields ('mode', 'rotor') that are not documented anywhere in the schema, which is genuine compensation, but the required wrapper fields (schema_version, idempotency_key, max_total_price) are not explained and the request contents are only partially enumerated.

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 — transforming Jones vectors or channel operators between named SU(2) frames and verifying invariants — which is concrete and understandable. It does not, however, distinguish itself from the closely related sibling wave_rotate_and_validate_two_channel_frame_v1, so an agent must open the schema to choose between 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?

The 'Problem / Input / Result / Limits' framing supplies context but never states when to use this tool rather than a sibling, nor any exclusion. The Limits line gives constraints (4 channels, 1024 samples) but no routing guidance, so the agent must infer the right situation.

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 declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, establishing this as a non-destructive, idempotent job. The description adds the bounded signal processing limits (8 channels, 4096 samples/channel), which is useful operational context. However, it doesn't disclose pricing, job status behavior, or result format beyond 'differences and rule results'—gaps that matter for a job-submitting tool in a marketplace context.

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

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

The description is extremely concise and well-structured using labeled sections (Problem, Input, Result, Limits). Every sentence serves a purpose and the information is front-loaded with the core comparison 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?

Given the tool's complexity (nested request object, job submission mechanics, pricing constraints) and the presence of an output schema, the description covers the core comparison logic and limits but omits critical operational details like pricing behavior, job lifecycle, and how to use the idempotency key. The output schema presumably covers return values, so that omission is acceptable.

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 all four parameters (schema_version, request, idempotency_key, max_total_price) are undocumented in both schema and description. The description mentions 'JSON with reference, reconstruction, rules' which hints at the request object contents, but doesn't map these to the actual parameter structure or explain idempotency_key and max_total_price requirements.

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 structured Problem/Input/Result/Limits format that clearly states the verb (compare/validate) and resource (reconstruction vs reference against acceptance rules). It distinguishes itself reasonably from siblings like wave_validate_spectral_criteria_v1 by focusing on reconstruction quality rather than spectral criteria, though it doesn't explicitly name 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 implies usage through its problem statement (comparing a reconstruction with a reference), but provides no explicit guidance on when to use this tool versus related validation tools like wave_validate_spectral_criteria_v1 or wave_verify_wave_pipeline_v1. There are no when-not or alternative conditions 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?

Annotations already declare idempotent, non-destructive, closed-world, and not read-only. The description adds concrete operational limits ('Bounded signal processing only; 8 channels; 4096 samples/channel'), which is genuinely useful. It omits the job-submission/commercial nature implied by the required max_total_price='0.005000' and idempotency_key, so the added context is partial.

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?

Labeled Problem/Input/Result/Limits structure is compact and front-loaded, with every line carrying content. The Problem framing is slightly verbose 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 re-explained, and limits plus inputs are covered. However, for a job-submitting tool with 0% parameter coverage, the description never clarifies the submission/retrieval model or pricing, leaving meaningful gaps.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It names nested request fields (sample rate hz, channel, normalization, rules) but gives no units, formats, allowed values, or meaning for the required top-level idempotency_key, schema_version, and max_total_price. Partial compensation for a total coverage gap.

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

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

States a specific verb and resource: 'Accept or reject this bounded capture against the caller's supplied spectral criteria.' An agent can tell this evaluates spectral rules against a capture. It does not, however, differentiate itself from near-neighbor validators like wave_validate_reconstruction_quality_v1 or wave_compare_waveform_captures_v1.

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 says what goes in and what comes out but never states when to prefer this over the other wave_* validation/compare tools, nor any prerequisites or exclusions. Usage must be inferred 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false, so safety and idempotency are covered. The description adds genuinely useful behavioral bounds beyond those annotations: 'Bounded signal processing only; 2 channels; 1024 samples/channel'. It does not mention the implied paid cost (max_total_price const) but the added limits are substantive and consistent with the annotations.

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

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

The Problem / Input / Result / Limits framing is front-loaded and each clause carries information (verb, inputs, outputs, constraints) with no filler. The 'wave_verify_wave_pipeline' naming redundancy aside, the prose itself is tight and well organized.

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

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

An output schema exists, so return values need not be explained, and the hard limits are supplied. However, given the freeform, undescribed `request` object and three undescribed required envelope params, the description is not complete enough for an agent to confidently construct a valid call, and it offers no routing guidance among the numerous pipeline siblings.

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 full burden. It enumerates request contents (sample rate hz, channels, operators, assertions) but omits the three other required envelope parameters (schema_version, idempotency_key, max_total_price), leaving the agent without meaning for idempotency_key or the pricing const. Partial compensation only.

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 verb pair (execute and verify) plus a concrete resource (bounded Wave IR pipeline), and states what it produces (execution result and shape/round-trip checks). It is clear on its own, but it never distinguishes itself from closely named siblings like wave_compare_pipeline_responses_v1 or wave_optimize_processing_pipeline_v1, so the agent has no explicit basis for picking it over 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 when-to-use statement, no prerequisites, and no alternatives named among the many wave_* siblings. The phrase 'optional round-trip assertions' hints at a verification use case but does not tell the agent when this tool is the right choice versus compare/optimize/validate variants.

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