RQM Studio Jobs

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

Annotations already declare destructiveHint=false, readOnlyHint=false and idempotentHint=true, so safety is covered. The description adds one genuinely useful behavioral fact beyond the schema - the candidate can be withheld/rejected if preservation is not verified - but says nothing about the paid-job nature implied by max_total_price/payment_rail or any async/rate-limit 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 a single front-loaded sentence with zero filler, which is structurally clean. However, that brevity is achieved by duplicating the title rather than by distilling additional information, so the conciseness comes at the cost of substance.

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

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

For a tool with a deeply nested request object, required idempotency/pricing fields, a payment selection, and a paid-job flow, one sentence is not enough. An output schema exists so return values need not be described, but essential context - what preservation means, what happens to a withheld candidate, cost/job semantics - is 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% across 4 parameters (request.original, request.candidate, semantic_context, claimed_transformation, plus top-level idempotency_key/max_total_price/payment_rail), and the description adds no parameter meaning whatsoever. Enum values such as standalone_circuit vs controlled_subcircuit, and the different semantics of 'original' vs 'candidate', are left 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?

Tautological: description restates name/title.

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

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

Usage is only implied: 'audit what another compiler or AI changed' suggests calling it after an external transform, and 'withhold the candidate unless preservation is verified' hints at the decision context. No explicit when-to-use, when-not-to-use, or alternative selection (e.g., vs compare_quantum_circuits) is given.

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

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

Annotations already cover the key traits: readOnlyHint=false, idempotentHint=true, destructiveHint=false. The description adds the important nuance that this is a request, implying cancellation may not be immediate or guaranteed, and that only authorized jobs can be cancelled. It stops short of stating what happens to in-flight jobs or partial results, so it adds 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?

A single, front-loaded sentence stating the action and scope. Every word earns its place with no redundancy or 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. Annotations and the full schema cover the structured details. The only remaining gap is the absence of prerequisite or post-call guidance, but the definition is largely complete for a single-purpose cancellation tool.

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

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

Schema description coverage is 100% and the anyOf variants fully document job_id, product, schema_version, and idempotency_key constraints. The description adds no further parameter meaning beyond what the schema already provides, which fits the baseline 3 when structured data does the heavy lifting.

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

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

The description states a specific verb (Request cancellation) and resource (product job). It uses 'one authorized product job' to scope it, which differentiates from submission siblings like submit_quantum_job and run_buyer_job, though it doesn't name the primary 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?

Usage is implied: request cancellation for one authorized product job. There is no explicit when-to-use guidance or mention of alternatives such as checking status first with get_job_status, nor any warning about jobs already completed. Adequate but with clear gaps.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is partially covered. The description adds that it returns a bounded go/no-go/unsupported decision with evidence, which is useful context. However, it doesn't explain cost implications despite required max_total_price and payment_rail parameters, nor does it describe what 'sending downstream' entails.

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

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

The description is a single efficient sentence that front-loads the purpose and outcome. It is concise with no wasted words, though it could be slightly more informative.

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

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

The tool has a complex schema with nested objects, required parameters, and an output schema. The description covers the high-level purpose but omits critical details such as parameter semantics, cost handling, and how the decision is determined. Given the complexity, it is only minimally complete.

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

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

Schema description coverage is 0%, but the description does not compensate by explaining any parameters. The parameters (idempotency_key, max_total_price, request.circuit, payment_rail) are entirely undocumented in both schema and description. Baseline 3 is assigned because with low coverage, the description should do more but does not. No credit for parameters.

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

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

Tautological: description restates name/title.

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 ('safe to send downstream') but doesn't explicitly state when to use this tool versus alternatives like quantum_openqasm3_preflight_v1 or quantum_provider_readiness_check_v1. No exclusions or prerequisites are provided.

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 and idempotentHint=true, but the description says nothing about cost, the required idempotency_key/max_total_price payment parameters, or what is computed versus stored. The description adds essentially no behavioral context beyond the title.

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 efficient sentence, but it is essentially a restatement of the title and carries no additional information payload, so the conciseness is not paired with value.

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

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

For a paid, multi-parameter, nested-schema tool with an output schema, the description omits pricing/payment parameters, idempotency expectations, and input format (matrix vs circuit). It is far too thin to guide 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 there are 4 parameters (including idempotency_key, max_total_price, payment_rail and a nested request with matrix/circuit), yet the description mentions none of them. It does not compensate for the complete lack of parameter documentation.

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

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

Tautological: description restates name/title.

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 alternatives named, no preconditions. With several overlapping two-qubit siblings in the list, the absence of routing information 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 declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds nothing beyond them: it does not explain that this is a paid/billed comparison (max_total_price, payment_rail), does not mention idempotency replay behavior, and does not describe what the output verdict contains even though an output schema exists. It does not contradict the annotations, but it contributes no 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?

It is a single short sentence with no padding, but for a four-parameter, nested-object, paid compute tool this is under-specification rather than conciseness. The one sentence duplicates the title rather than front-loading the information an agent 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?

The tool has four parameters (three required), nested request objects, an enum for semantic_context, a pricing parameter, and an idempotency key. None of these are addressed, and the 'phase context' referenced in the sentence is never defined relative to the semantic_context enum values. The definition is materially incomplete for 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 the description mentions none of the four parameters. It never explains idempotency_key, max_total_price, payment_rail, or the nested request.original/candidate/semantic_context structure, so the caller must reverse-engineer formats and pricing semantics from the schema 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?

Tautological: description restates name/title.

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 when-not-to-use, and no alternative tool named. With roughly a dozen equivalence/comparison siblings in the list, the absence of routing guidance is a serious 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 idempotent, non-destructive, open-world, non-read-only, yet the description repeats 'idempotent' rather than adding new behavioural detail. It omits what the returned URL does, expiry, and that funding is an external side effect on Stripe – useful context for an open-world mutation that the description fails to supply.

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 compact sentence with no filler and the key verb('create') front-loaded. Slight inefficiency because 'idempotent' duplicates the annotation rather than adding 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?

Output schema exists so return structure need not be explained, and annotations cover safety flags. However, for a three-param, open-world mutation with zero schema descriptions, an agent needs to know what happens to a reused idempotency_key and what amount units mean – neither is addressed.

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 names zero of the three required parameters. The 'idempotent' claim loosely maps to idempotency_key but gives no syntax or collision semantics; amount and schema_version are wholly unmentioned in prose.

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

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

States a specific verb+resource ('Create a ... Stripe Checkout URL') and adds the qualifying scope 'for human prepaid funding', which no sibling covers. It stops short of 5 only because it doesn't name or contrast with any sibling tool.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance. An agent cannot tell from the description whether this precedes run_buyer_job or is the sole funding path. 'Human prepaid funding' hints at a context but is not actionable 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 declare idempotentHint=true and destructiveHint=false, so the description adds little on safety. The real behavioral payload -- that this requires a paid call (max_total_price), supports x402/account_core_balance payment rails, and is idempotency-keyed -- appears nowhere in the description.

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

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

A single sentence is maximally concise and front-loaded, but that brevity reflects under-specification rather than disciplined editing.

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

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

The schema is deeply nested with a 3-level required request object, a custom recursive type, and three required top-level parameters, yet the description covers only the abstract goal. An output schema exists so return values need not be explained, but the inputs and call mechanics are not.

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, but it adds nothing about original vs candidate circuits, the format enum (openqasm3 / rqm_circuit_ir_0_2), semantic_context, or the pricing/idempotency parameters.

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

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

Tautological: description restates name/title.

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 the many overlapping phase/diagnosis siblings. The agent must guess which of these tools applies.

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, readOnlyHint=false and openWorldHint=false, covering the safety profile. The description adds nothing on top: it never mentions that this appears to be a paid operation (max_total_price, payment_rail) or what 'bounded corrective actions' output looks like. With a lower bar due to annotations, a 2 reflects zero added 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?

It is short, but not because it is efficient — it is a literal duplicate of the title, so the sentence earns no place. Conciseness here is under-specification rather than economy of language.

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

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

For a tool with four required/near-required parameters, nested request objects, an enum-driven failure_stage, payment handling, and several overlapping diagnostic siblings, the description is completely inadequate. The existence of an output schema excuses return-value detail, but nothing else is covered.

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 parameters (idempotency_key, max_total_price, payment_rail, and a deeply nested request object), so the description is the only place semantics could be supplied — and it supplies none. Notably the required payment parameters are never explained, leaving an agent unable to know how pricing or idempotency keys are meant to be formed.

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?

Tautological: description restates name/title.

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, when not to, or which alternative to prefer. The implied context (a workflow already failed) is the only usage signal, and it is not expressed; nor does it distinguish itself from quantum_failed_workflow_diagnosis_v1 or diagnose_quantum_phase.

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, covering the safety profile. The description adds two useful facts beyond them: the call is authenticated and the balance is prepaid and denominated in USD.

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. Every word (authenticated, canonical, prepaid, USD) narrows the scope of the resource, so 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-value structure need not be described, and the annotations fully cover safety and idempotency. The description is adequate for a no-argument read tool; only a hint about the account scope (e.g. per-workspace vs global) is 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 coverage is 0% and the single parameter (schema_version) is an opaque version const that the description never mentions. However, a fixed const discriminator carries no real semantic decisions for the agent, so the omission is minor; baseline 3 holds.

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

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

The description pairs a specific verb ("Read") with a specific resource ("authenticated canonical Account Core prepaid USD balance"), and no sibling tool competes for that purpose. It is clear but relies on internal jargon ("canonical Account Core") that an agent has no external referent for.

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

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

No explicit when/when-not guidance or named alternatives, but usage is strongly implied by the name and the read-only nature of a balance check. An agent can infer this is the tool for checking prepaid funds, though the description never says so.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds real context with 'approved public' (only approved, publicly visible capabilities are returned) and 'full' (complete descriptor rather than a summary), but says nothing about auth, error behavior, or not-found handling.

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

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

A single compact sentence with the verb and resource front-loaded and no filler. It is efficient, though arguably too terse for a tool whose schema exposes four request variants.

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 description is not required. Against a four-variant anyOf request schema and a large sibling set, however, the description omits variant selection guidance (which schema_version/product to send) and any routing to list_capabilities, leaving 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?

Per the context there are 0 top-level parameters and schema description coverage is 100%, which normally sets a baseline of 4. The description adds no meaning of its own and does not explain the product/capability_id/schema_version request variants (v1-v4) expressed in the anyOf; its 'Wave' wording could mislead about the product field, so it sits below the baseline.

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 ('Return') and resource ('one full approved public Wave capability descriptor'), and the singular 'one' implicitly contrasts with the sibling list_capabilities. However it never names that sibling explicitly, and narrowing to 'Wave' is slightly at odds with the schema's multi-product (wave/quantum/robotics) request variants.

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 mention of list_capabilities as the alternative for enumerating capabilities, and no prerequisites or conditions. The agent must infer that this is the single-item lookup variant purely from the word 'one'.

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 the meaningful constraint that only completed/settled jobs yield a result, implying failure otherwise, but it omits error behavior, retry semantics, or result freshness. With annotations carrying most of the load, this is adequate.

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

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

A single front-loaded sentence with no filler or redundancy. It is arguably too terse for a tool with four schema variants, but every word earns its place.

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

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

An output schema exists, so return values need no explanation, and annotations cover safety. What is missing is differentiation from the close siblings get_job_status and get_job_artifact and any hint about the versioned reference variants in the schema, which matters 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 100% and the anyOf branches document product/schema_version via const and enum values, so the schema does the heavy lifting. The description adds no detail about job_id format, the product variant selection, or the versioned reference shapes the schema offers. Baseline 3 applies.

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

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

States a specific verb (Read) and resource (one product result) and qualifies scope with 'completed and already-settled', which distinguishes it in spirit from get_job_status. However, it never names get_job_artifact or get_job_status, so an agent must infer the boundary between 'result', 'status', and 'artifact' on its own.

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' implicitly defines a precondition for use, which is better than nothing. But there is no explicit when-to-use versus get_job_status (check progress) or get_job_artifact (retrieve files), nor any statement about what happens if the job is not yet settled.

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, non-destructive, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only the word 'authorized', hinting at permission scoping, but says nothing about what state is returned or any access constraints.

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. It is arguably too terse given the routing ambiguity, 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 and full annotations exist, so return values and safety need not be re-explained. Still, against a sibling set containing cancel_job, get_job_result, and get_job_artifact, the definition omits the distinctions an agent needs, leaving a real gap.

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

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

Schema coverage is 100% with the job reference variants (job_id, product enum, schema_version) fully typed in the input schema, so the schema does the heavy lifting. The description's 'one ... job' adds only a marginal hint that a single job is addressed.

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 ('Read') and resource ('one ... job') and scopes it to Wave/Studio managed-simulator jobs, which is useful domain narrowing. However it does not distinguish itself from close siblings such as get_job_result and get_job_artifact, so an agent cannot tell from the text alone why it would pick this one.

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 use this versus cancel_job, get_job_result, or get_job_artifact. The description only names the object it reads, leaving all routing decisions to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds only 'durable' and the 'settled' precondition; it says nothing about what happens when the reservation is unsettled, missing, or belongs to another account, nor about any rate or retention constraints.

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 13-word sentence with the scope constraint ('one settled Studio reservation') front-loaded and no filler. Nothing to trim.

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 posture. However, with 0% parameter documentation and no error/precondition behavior, the description is only minimally complete for a lookup 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% and the description never mentions reservation_id or schema_version. The format/pattern/const in the schema are self-documenting, and 'one settled Studio reservation' loosely implies what reservation_id means, but the description does not compensate for the documentation gap on a 2-parameter required surface.

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 (Retrieve), a precise resource (durable Account Core receipt), and scopes it to one settled Studio reservation. No sibling tool deals with receipts, so differentiation is implicit rather than stated, keeping it just below 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 'for one settled Studio reservation' implicitly tells the agent this applies only to settled reservations, but there is no explicit when-to-use/when-not guidance or named alternative for unsettled or non-Studio cases. Usage is implied, not 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 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety behavior is covered. The description adds one genuine trait beyond the annotations: that v0/v1 output is 'preserved' (static) while the v2/v3 Wave catalog is 'dynamic'. That distinction is useful but thin relative to the tool's apparent complexity.

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; it immediately states the two output modes. The compression comes at some cost to clarity, but nothing is padded.

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 documentation is not required. Yet the input schema offers six const-variant branches for schema_version/product, and the description only vaguely gestures at 'v0/v1' versus 'v2/v3', leaving an agent uncertain which schema_version value to supply. Adequate but incomplete for the schema's complexity.

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

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

With zero counted parameters, the baseline is 4, and schema description coverage is reported at 100%. The description loosely maps its version language (v0/v1 vs v2/v3) onto schema_version variants, adding mild meaning, though it does not name the actual const strings the schema requires.

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 conveys that the tool surfaces a capability catalog and distinguishes two modes ('preserved v0/v1 surface' vs 'dynamic v2/v3 Wave catalog'), which hints at what it returns. However, the phrasing is jargon-heavy and never plainly states it lists all available job capabilities, nor does it differentiate itself from the sibling get_capability (singular). Purpose is inferable but not crisp.

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 guidance is given. The two version modes are named but the description never tells the agent which to choose or when to prefer this over get_capability. Usage must be inferred entirely from the name and title.

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 the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower. The description still adds real value beyond them by disclosing the conditional fallback semantics: the circuit is only swapped for the smaller version if equivalence is verified, otherwise the original is returned.

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, front-loaded sentence with no padding, but it is essentially a restatement of the title and leaves out information this complex tool needs. Brevity here comes from omission rather than efficiency.

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 paid, nested-schema transformation tool with an output schema and multiple overlapping siblings, the description omits the cost/payment model (max_total_price, payment_rail), the meaning of the profile option, supported circuit formats, and idempotency behavior. The equivalence guarantee is the only substantive content.

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 parameters (including a nested request object with circuit/backend/profile, plus payment_rail, idempotency_key, and max_total_price). The description explains none of these, so an agent gets nothing about the profile enum, supported formats, or the pricing/idempotency 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?

Tautological: description restates name/title.

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 quantum_verified_circuit_optimization_v1, quantum_phase_aware_rewrite_v1, or quantum_openqasm3_preflight_v1. The agent must infer usage 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 safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower. The description nonetheless adds real behavioral context beyond the annotations: the evidence is local-software-only, bounded to 3 verification qubits and 65536 source bytes, and it returns warnings plus normalized source. It stops short of explaining the price/idempotency interplay implied by the schema.

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

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

Four labeled fragments (Problem/Input/Result/Limits) front-load the purpose and scope with zero filler. Every clause earns its place and the limits are surfaced up front.

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

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

An output schema exists, so the return values need not be detailed again, and the description adequately previews them. However, for a tool with 4 required params, nested objects, and 0% schema coverage, the near-total silence on parameters and on sibling differentiation 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% on 4 required parameters, so the description must carry the burden and does not. It says 'JSON with source', but the required top-level fields (schema_version, idempotency_key, max_total_price) are never mentioned, and 'source' is actually a nested field inside 'request'. The wrapper request shape is left 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 uses specific verbs and resource ('Validate, compile, and report bounded assurance evidence for OpenQASM 3'), so an agent knows it produces an assurance report from QASM 3 input. It does not, however, distinguish this from closely related siblings like quantum_openqasm3_preflight_v1 or check_quantum_circuit, leaving the agent to 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?

There is no explicit when-to-use, when-not, or named alternative guidance. The 'Limits' line scopes the tool (local evidence, 3 qubits, 64KiB) but never says when an agent should pick this over preflight, check, or repair tools. Usage is only weakly implied by the 'assurance report' 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 declare readOnlyHint=false, idempotentHint=true and destructiveHint=false. The description adds useful constraints: no silent gate substitution, explicit gate mapping, source/artifact digests, and 65536 source byte limit. But it does not explain what the digest is for, what happens on partial translation failure, or whether the target format must be a supported toolchain. Moderate value beyond annotations.

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

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

Uses a tight Problem/Input/Result/Limits structure that is front-loaded and easy to scan. Each sentence earns a place, though the labels are terse and the input line is misleading relative to the schema.

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-value detail is not required, and the description covers the core translation contract plus limits. However, for a 4-required-param tool with nested request object and 0% schema coverage, the definition omits critical parameter meaning, and the 'Input' line contradicts the actual required fields.

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 4 top-level params (schema_version, request, idempotency_key, max_total_price) are entirely undocumented in the schema. The description says 'Input: JSON with source, target format' but the schema's required fields are different and nested, so it does not actually explain the required 'request' object or the pricing/idempotency fields. 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: translate OpenQASM 3 circuit to target toolchain format with explicit gate mapping. Distinguishes from siblings like translate_quantum_circuit by emphasizing 'without silent gate substitution' and the local toolchain target. Clear enough, though the hyphenated 'v1' naming is redundant with the title.

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?

Frames the task as 'Problem:' which implies when to use it, and mentions the input format. But it never says when NOT to use it or names an alternative such as translate_quantum_circuit or quantum_provider_target_compile, which appears to be the closest sibling. Usage 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 idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is largely covered. The description adds real value beyond them by disclosing hard limits (4096 operations, 65536 request bytes, local-software evidence only) and the shape of the result. It stops short of describing side effects or whether the operation creates persistent state.

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

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

The Problem/Input/Result/Limits structure is front-loaded and each clause carries information with no filler. It is slightly terse on the Limits line, 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-value detail is not strictly required, and the annotations cover idempotency and safety. However, for a 4-parameter tool with 0% schema coverage and nested objects, the description omits the identity/idempotency-key semantics and the max_total_price const, leaving the calling contract incomplete.

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

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

Schema description coverage is 0% with 4 required top-level parameters, so the schema alone is opaque. The 'Input' line documents the inner request fields (plans, weights, maximum cost usd, depth, duration) which compensates somewhat, but the outer required fields — schema_version, idempotency_key, max_total_price — and the const value '0.010000' 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?

The opening sentence names a specific verb (select) and resource (execution plan) and states the constraint dimensions (cost, depth, duration, weights). It is clear what the tool does, though it does not distinguish itself from decision-oriented siblings such as quote_job or run_buyer_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?

There is no when-to-use guidance and no named alternative. The description explains inputs and outputs but never says when an agent should pick this planner over quoting or running a job, leaving selection inference to 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 already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description usefully adds the evidence boundary ('Local software evidence only') and the 65536-byte request cap, which are not derivable from annotations. However it omits that this is a paid job submission (max_total_price) and says nothing about cost or async job behavior.

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

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

The Problem/Input/Result/Limits labeling is compact, front-loaded, and wastes no sentences. It is slightly terse to the point of under-specification, but structurally efficient.

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 re-explained. But for a job-submitting tool with a price constraint, idempotency key, and 0% parameter documentation, the description leaves the invocation contract 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 description coverage is 0% across 4 required parameters. The description only hints at 'JSON with stage, error text', which does not even correspond to the top-level parameters (request, schema_version, idempotency_key, max_total_price). Nothing explains the idempotency key format, the fixed price constant, or the schema version.

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: 'Diagnose why this bounded quantum workflow failed and return supported corrective actions.' It is clear what the tool produces (failure class, evidence terms, corrective actions), but it never distinguishes itself from the very similar sibling 'diagnose_quantum_workflow'.

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 mention of alternatives, despite a near-identical sibling ('diagnose_quantum_workflow') that an agent must choose between. The 'Limits' line constrains scope but does not help tool selection.

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

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

Annotations cover idempotency, non-destructiveness and closed-world scope, and the description adds the 'local software evidence only' limit and a byte cap. But it hides the most consequential behavior: the schema's max_total_price const and idempotency_key indicate this is a paid, job-submitting operation, and the description never says a job is queued, that funding is required, or how results are retrieved. That omission is serious for a non-read-only tool.

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

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

The Problem/Input/Result/Limits structure is front-loaded and compact, with no filler sentences. Slightly dense but every block earns its place.

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

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

An output schema exists so return values need not be described, and the description does convey the transformation and its bounded-evidence limits. It is nonetheless incomplete for a paid, idempotent job tool whose request envelope and payment parameter are invisible to the reader.

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 payload is an untyped open object, so the description carries the full burden. It names only operation, target basis and phase context, leaving the required schema_version, idempotency_key and max_total_price parameters, plus the pricing semantics, 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?

States a specific verb+resource (decompose a circuit operation into a supplied bounded gate basis, then verify the relation), which is more specific than the name alone. However 'this supported circuit operation' is vague and the description does not distinguish it from closely named siblings such as quantum_two_qubit_target_synthesis_v1 or synthesize_two_qubit_target.

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, and no routing to alternatives despite many overlapping decomposition/synthesis siblings. The Problem/Input/Result/Limits framing implies a workflow but never states the conditions that select this tool over its neighbors.

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 safety/idempotency is covered structurally. The description adds useful behavioral context: the qubit/operation bounds and the nature of the returned evidence ('typed counts, probabilities, simulation configuration evidence'). However, it omits any mention of cost/billing despite the request carrying max_total_price, and readOnlyHint=false suggests a job-creating operation the description presents purely as local execution.

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 each clause carrying meaning. Minor waste in the verbose framing but no filler.

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

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

An output schema exists, so return values needn't be described. Yet for a 4-parameter job-submission tool with nested request objects and 0% schema coverage, the description leaves the input contract and the pricing/idempotency semantics unexplained, which is a meaningful gap.

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

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

Schema description coverage is 0% across 4 required parameters, so the description must carry the burden and largely fails. It vaguely says 'Input: JSON with circuit ir' but never explains idempotency_key, max_total_price (set to a fixed 0.010000), or schema_version — the pricing field in particular is critical and 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 and resource: 'Execute a bounded RQM Circuit IR circuit on the managed local statevector simulator.' This is clearly distinguishable from siblings like run_buyer_job or submit_quantum_job, though it does not explicitly contrast itself with the other simulation/diagnostic tools (e.g., quantum_simulation_anomaly_diagnostic_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 guidance on when to choose this tool over alternatives like run_buyer_job, submit_quantum_job, or the many other quantum_* simulation and diagnostic tools. The 'Limits' line states hard constraints (16 qubits, 250 operations) but gives no when/when-not routing.

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

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

Annotations cover the safety/idempotency profile (idempotentHint=true, destructiveHint=false, openWorldHint=false), and the description adds real behavioral context beyond them: possible outcomes (go/no-go/unsupported), produced artifacts (normalized source, warnings, evidence), and concrete limits (local evidence only, 3 verification qubits, 65536 source bytes). It does not mention that the call carries a price, which is a notable omission given max_total_price is required, but nothing contradicts 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 compact, front-loaded, and wastes almost no words; every clause carries information. It is slightly telegraphic for a tool with a 4-field required envelope, but density here is a virtue rather than padding.

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

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

An output schema exists, so verdict/warning detail need not be re-explained, and the description covers purpose and limits adequately. What is missing is the calling contract: the required request envelope, idempotency key, and pricing field are undocumented in both schema and description, which leaves an agent under-informed for a paid, job-submitting tool with a nested object parameter.

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 burden falls on the description, and it only partly delivers: 'JSON with source' gestures at the payload, but schema_version, idempotency_key, and max_total_price are never explained, and the nested 'request' envelope is opaque. A user cannot tell from the text where 'source' actually lives in the schema.

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

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

The description names specific verbs and resource: 'Parse, normalize, and assess OpenQASM 3 before downstream execution.' That is far more than a restatement of the title and tells the agent this is a validation/preflight step, not an executor. It does not, however, set itself apart from the very similar sibling quantum_openqasm3_repair_v1 / repair_openqasm3.

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?

'before downstream execution' implies when this belongs in a workflow, but there is no explicit when-not guidance and no routing to alternatives such as repair_openqasm3 or check_quantum_circuit in the sibling list. Usage is inferable 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 not-read-only, idempotent, non-destructive, and closed-world. The description adds real behavioral context beyond them: the tool may withhold rather than repair ('repaired or withheld source'), returns an exact edit list plus a post-repair validation verdict, and is limited to local software evidence and 65536 source bytes. It still omits pricing/auth semantics implied by max_total_price and idempotency_key.

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 front-loads purpose and constraints in four short clauses with essentially no filler. It is well sized for the amount of information conveyed.

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, but with 0% schema coverage the description should compensate for the opaque request/price/idempotency parameters and does not. For a job-submitting tool with a fixed price ceiling and idempotency contract, the agent lacks the information needed to construct a valid call.

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

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

Schema description coverage is 0% and all four required parameters are untyped blobs to the reader. The description names only 'source' and 'allowed repairs' inside the opaque request object, and says nothing about schema_version, idempotency_key, or max_total_price – so most parameters remain undocumented in both places.

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 (repair) and resource (bounded OpenQASM 3 program) with a scoping qualifier ('only with the supplied conservative repair policy'). However, it never distinguishes itself from the near-identical sibling repair_openqasm3, leaving an agent unable to tell the two apart without inspecting both schemas.

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 a constraint ('only with the supplied conservative repair policy') but no when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (repair_openqasm3, quantum_openqasm3_preflight_v1, quantum_phase_aware_rewrite_v1). 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 supply the safety profile (idempotentHint=true, destructiveHint=false, openWorldHint=false) and the description adds genuine operating limits: local software evidence only, 3 verification qubits, 65536 request bytes. However, it doesn't explain why readOnlyHint=false for what is framed as an audit, leaving a notable behavioral trait 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 scaffold is front-loaded and scannable, but the 'metric and....' fragment is truncated and incomplete, undercutting the structure. Otherwise reasonably compact.

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 stated limits add useful framing. Still, with zero parameter documentation and no routing guidance against many similar siblings, the definition leaves real gaps for an agent preparing a call.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, yet it only hints at 'original circuit, candidate circuit' (nested inside request) and omits schema_version, idempotency_key, and max_total_price entirely. With four required parameters effectively undocumented, the description compensates only partially.

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: audit candidate optimization equivalence and coupling preservation. It distinguishes itself somewhat from generic siblings like compare_quantum_circuits or audit_quantum_transformation by naming 'optimization equivalence' and 'qualitative coupling preservation', though it doesn't explicitly contrast them.

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

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

No when-to-use guidance and no comparison to alternatives, despite a crowded sibling set (quantum_verified_circuit_optimization_v1, audit_quantum_transformation, compare_quantum_circuits) that an agent must disambiguate against. The description never states the conditions that 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 already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety envelope is covered. The description adds genuine value beyond that: it discloses the return shape (rewritten operation or original), a non-obvious 'candidate withholding' behavior, a verification-status field, and hard limits ('local software evidence only', 65536 request bytes). That is substantive 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 framing is front-loaded and wastes no words. It is telegraphic but every clause carries information, and scoping limits are placed last as expected. Minor cost is that the terse style reads like a contract rather than task activation.

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 explaining return values is not strictly required, and the description covers result and limits. However, for a non-read-only tool carrying a max_total_price const and idempotency_key, the description never addresses cost/purchase semantics or when the job-spending path applies, which is an important context gap for a complex mutating 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, so the description must carry the burden. It only loosely points at the payload ('operation, target gate, phase context') while the actual required envelope — schema_version, request, idempotency_key, and especially max_total_price — is never explained. The price field is the most consequential one and is left entirely opaque, so compensation is inadequate.

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 and resource: 'Rewrite this supported circuit under the supplied phase-equivalence and target constraints.' That is clear and more precise than a tautology. It stops short of naming which sibling tool to prefer (e.g., quantum_supported_circuit_equivalence_v1 or quantum_two_qubit_target_synthesis_v1), so the agent must infer the boundary itself.

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. The phrase 'supported circuit' and 'phase-equivalence constraints' implies a context, but among ~40 quantum siblings the description never states the condition that selects this rewrite tool over the equivalence, synthesis, optimization, or inspection tools. The agent is left to guess.

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 — a slightly contradictory safety profile the description doesn't address (why is it non-read-only if it's an inspection?). The 'Limits' sentence adds useful context (local evidence only, 65536 bytes), partially compensating.

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

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

Front-loaded Problem/Input/Result/Limits structure is efficient and scannable. Minor waste in the vague 'these supported operations' phrasing.

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?

Four required params at 0% schema coverage, nested objects, and a non-obvious idempotency/pricing envelope go unexplained. Even with an output schema covering the result, the input contract is effectively undocumented.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It only loosely maps ('reference, candidate, phase context') to the actual request object, and says nothing about schema_version, idempotency_key, or max_total_price — three of four required params.

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 diagnosis task (phase, rotation, ordering, convention difference) but is vague about the specific resource and doesn't clearly differentiate from the close siblings diagnose_quantum_phase and quantum_two_qubit_local_equivalence_v1. 'these supported operations' is an unresolved reference.

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 guidance, no when-not-to-use, and no mention of the near-identical sibling diagnose_quantum_phase. The agent has no basis for choosing this tool over that one.

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, and the description usefully adds the operational limits ('Local software evidence only; 4096 operations; 65536 request bytes') plus the result shape. It does not explain why readOnlyHint is false for what is nominally a 'check', nor does it address the pricing/idempotency semantics implied by max_total_price and idempotency_key.

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 easy to scan, and each clause carries information. It packs a lot into a few lines without redundancy.

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

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

An output schema exists, so return-value detail is not required, yet the description still lists the result structure helpfully. For a nested, 4-required-param tool, though, the absence of any guidance on the envelope params and the pricing/idempotency fields leaves material 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 parameter meaning, but it describes the inner request payload (qubit count, operations, target, rules) rather than the actual top-level parameters. It never explains schema_version, the request envelope, idempotency_key, or max_total_price, leaving all four required params 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 states a concrete decision verb and resource: 'Accept or reject this bounded circuit for the supplied pinned provider target and readiness rules.' This distinguishes it from transformation/compilation siblings that mutate or translate circuits. However, it never names the likely alternative tools (e.g. quantum_openqasm3_preflight_v1, quantum_provider_target_compile_v1) that an agent might otherwise 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?

There is no explicit when-to-use statement, no prerequisites, and no exclusions relative to the many sibling readiness/compile/preflight tools. The 'Problem:' framing implies a use case but leaves the routing decision 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 cover the safety/idempotency profile (readOnly=false, destructive=false, idempotent=true), and the description adds concrete constraints the annotations omit: 'Local software evidence only', a 4096-operation bound and a 65536-byte request cap. These limits materially affect how an agent should size and scope a call.

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?

Organized as Problem/Input/Result/Limits, front-loading the purpose and keeping each element to a clause. Very little waste, though the telegraphic phrasing is terse to the point of being cryptic in places.

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 explained, and annotations carry the behavior profile; the description usefully adds limits and input shape. It still leaves the four required parameters undocumented, which is a notable gap for a tool with nested, fully-uncovered inputs.

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 none of the four required top-level parameters (schema_version, request, idempotency_key, max_total_price) are documented. The description partially compensates by naming the request's inner fields (left counts, right counts, normalization, rules), but the envelope parameters and pricing/idempotency semantics remain 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 precise verb (compare) and resource (bounded provider results) with the mechanism (supplied normalization and difference rules), which is more specific than the title. It is separable from siblings like quantum_simulation_result_compare_v1 by the 'provider results' framing, though it does not explicitly name what it is not.

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 gives context on what it expects, but there is no statement of when to choose this over compare_quantum_circuits or quantum_simulation_result_compare_v1, and no prerequisites or when-not conditions. An agent must infer selection 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 idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real value beyond that: 'Local software evidence only' (no hardware execution), a 4096-operation cap and a 65536-byte request cap, plus the shape of the returned evidence. It omits the pricing implication of the required max_total_price parameter, which is the one significant gap.

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

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

A tight four-label Problem/Input/Result/Limits structure, front-loaded with purpose and ending with hard numeric limits. Every clause carries information; nothing is redundant with the title or name.

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

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

An output schema exists, so the description need not enumerate return values, and it still summarizes them helpfully. However, for a 4-required-parameter tool with 0% schema coverage and a payment-flavored max_total_price const, the definition leaves the required-parameter contract and the idempotency/price semantics 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%, so the description carries the full burden. It names three fields (qubit count, operations, target) that live inside the nested 'request' object, but it never explains the two other required top-level parameters, idempotency_key and max_total_price, nor the required schema_version const. Half the required input surface is undocumented in both places.

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 this bounded circuit to the supplied pinned provider target') and the returned evidence type, which is enough to separate it from siblings like quantum_provider_readiness_check_v1 or quantum_execution_plan_select_v1. It stops short of naming any sibling, so differentiation is inferred rather than stated.

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

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

There is no when-to-use/when-not guidance and no mention of the alternatives in this crowded family of ~14 quantum_* tools. The phrase 'bounded circuit' hints at a precondition but never states what qualifies or which sibling to use instead when the circuit is not 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 already declare destructiveHint=false, idempotentHint=true, openWorldHint=false, and readOnlyHint=false. The description adds genuinely useful behavior beyond that: local-software-only evidence scope and a 65536 request-byte limit. However, it never discloses that this is a paid job submission (max_total_price) or what the readOnly=false/idempotent semantics mean in practice, so disclosure 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?

The Problem/Input/Result/Limits labeling is efficient and front-loaded, with no filler sentences. The trailing ellipsis ('maximum l1 error....') is slightly untidy but does not undermine the structure.

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, yet the description does sketch them anyway. Given a nested, open request object and a job-wrapper schema, the definition is adequate but omits the payment/job-creation context an agent needs 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 request object is fully opaque, so the description must compensate. It partially does by naming inner request fields (observed/expected probabilities, maximum l1 error), but it leaves schema_version, idempotency_key, and max_total_price unexplained, so the four-parameter surface is only partially illuminated.

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 (Compare) and resource (bounded simulation result vs. supplied expectations and anomaly rules) and states the outcome (anomaly verdict). It distinguishes the tool conceptually from compare-style and workflow-diagnosis siblings, though it never names an 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 explicit when-to-use or when-not guidance, and no routing to alternatives despite several overlapping siblings (quantum_simulation_result_compare_v1, diagnose_quantum_workflow, quantum_failed_workflow_diagnosis_v1). 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 state readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful operational limits (local software evidence, 4096 operations, 65536 request bytes) and the deterministic nature of the comparison, but it does not explain billing, side effects, or what exceeding limits does.

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

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

The description is front-loaded with a clear Problem/Input/Result/Limits structure and uses every sentence efficiently. No wasted words.

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

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

Given the nested request object, required billing parameter (max_total_price), idempotency key, and schema version, the description is incomplete for correct invocation. It does not explain how to format the request or the role of the required envelope fields, even though an output schema exists.

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

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

Schema description coverage is 0%, so the description must carry the burden. It names left probabilities, right probabilities, and rules, but omits the required top-level parameters idempotency_key, max_total_price, and schema_version, leaving agents without guidance on critical fields.

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 (Compare) and resource (bounded simulation results) and mentions the deterministic probability rules used. It is clear what the tool does, but it does not explicitly differentiate itself from siblings like quantum_provider_result_compare_v1 or compare_quantum_circuits.

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

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

There is no explicit guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The 'Problem:' framing implies a use case but leaves routing 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 declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and the description adds concrete operational limits (local software evidence only, 3 verification qubits, 65536 request bytes), which are real value beyond the annotations. However, it omits the paid-job semantics implied by the required max_total_price and idempotency_key, and says nothing about latency or evidence format.

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 well front-loaded and compact for the amount of content. It loses a point for the truncated 'input....' fragment, which reads as unfinished rather than concise.

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

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

An output schema exists, so return values need not be re-explained, and the verdict/evidence framing is adequate. Still, for a 4-parameter paid job tool with nested request objects and zero schema descriptions, the definition leaves the agent guessing about request envelope fields and pricing.

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 four required parameters, so the description carries the full burden. It only explains the nested 'request' content (original and candidate circuit) and leaves schema_version, idempotency_key, and the fixed max_total_price price cap entirely unaddressed.

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 ('Compare two RQM Circuit IR circuits') plus a qualifier ('within the supported verifier scope') that separates it from broader siblings like compare_quantum_circuits. It does not name any sibling directly, so differentiation is inferable rather than explicit.

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

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

The phrase 'within the supported verifier scope' and the 'unsupported' verdict imply when this tool applies, but there is no explicit when-to-use/when-not guidance relative to the many sibling comparison tools (compare_quantum_circuits, quantum_two_qubit_local_equivalence_v1, quantum_simulation_result_compare_v1).

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 safety/idempotency profile is covered. The description adds the 'local software evidence only' scope and lists the result components, but it never discloses that the schema implies a priced job submission (max_total_price, idempotency_key) or any async/return-timing behavior, so it contributes only moderate insight.

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 front-loads the purpose and is easy to scan with no wasted wording. It is appropriately sized for a single-purpose classification tool.

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

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

An output schema exists, so return values need not be described, and the description does list the result components. However, for a tool whose schema includes pricing ceilings and idempotency keys inside a nested request object, the definition omits any explanation of the request payload structure, leaving a real gap 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 four required parameters (request, schema_version, idempotency_key, max_total_price), and the description only loosely gestures at 'Input: JSON with operation, phase context.' It never names or explains idempotency_key, max_total_price, or schema_version, so it fails to compensate for the documentation 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 (classify) and a well-scoped resource (a supported two-qubit operation) along with the classification criterion (bounded local-equivalence class). It does not, however, differentiate itself from the closely-named sibling classify_two_qubit_operation, leaving the agent to infer the distinction from the phrase 'local-equivalence'.

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 a scope boundary (local software evidence only; 2 qubits), which is useful context, but there is no explicit when-to-use guidance and no mention of alternatives such as classify_two_qubit_operation or check_quantum_circuit. The agent must guess when this tool is preferred.

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. The description adds genuine context beyond them: "Local software evidence only" (matching the closed-world claim) and "original-retained outcome," implying the original is preserved when verification fails. It does not clarify pricing behavior despite a const price field, so it adds some but not rich value.

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 templated Problem/Input/Result/Limits layout is front-loaded and efficient in principle, but the Result sentence literally trails off ("gate count and depth, class and...."), so the structure is marred by a truncated fragment rather than wasted verbosity.

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 job-submission tool with a nested free-form request body, a required idempotency key and a price cap, the description omits idempotency/retry semantics and billing behavior. Although an output schema exists (so return values need not be explained), the input-side gaps leave an agent without enough to invoke the tool correctly.

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

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

Schema description coverage is 0% and the "request" parameter is a free-form object with untyped additionalProperties. The description lists intended request contents (operation, target basis, phase context, objectives), which gives partial semantic grounding, but it says nothing about the other required parameters idempotency_key or max_total_price, so the burden is not met.

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

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

The description names a concrete verb and resource ("choose and verify a bounded target-basis implementation" for a two-qubit operation), so the intent is recoverable. However it is wrapped in garbled framing ("Problem:", "Result:") and never distinguishes itself from the near-identical sibling synthesize_two_qubit_target, leaving an agent unable to tell the two apart.

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

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

There is no when-to-use / when-not-to-use guidance and no alternatives named, even though the sibling list contains synthesize_two_qubit_target (almost the same name), classify_two_qubit_operation, and quantum_gate_basis_decomposition_v1. "Under supplied objectives" and "supported two-qubit operation" hint at scope but do not route the agent.

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

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

Annotations only cover safety/mutability flags (readOnly=false, idempotent=true, destructive=false); the description adds meaningful behavior beyond them: the original is returned as a fallback when preservation fails, and the return carries metric deltas and preservation evidence. The stated limits (local software evidence only, 3 verification qubits, 65536 request bytes) further constrain use. It does not discuss permissions or cost implications of the 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 telegraphic, with each clause carrying information. It is compact, though the terse fragments for Input and Result sacrifice some clarity for brevity.

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

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

An output schema exists, so return values need not be spelled out, and the description usefully explains the fallback and evidence anyway. However, for a nested, fully undocumented request object with an unusual fixed-price parameter, the input side is under-specified for an agent 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% across 4 required parameters, so the description must carry the load, but it only says the input is 'JSON with circuit.' The nested request object, the const schema_version, the idempotency_key pattern, and especially the const max_total_price ("0.250000") are not explained at all.

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 RQM Circuit IR) plus the distinguishing behavioral twist (return the original unless preservation is verified), which sets it apart from the plain optimize_quantum_circuit sibling. It stops short of naming the alternatives it is not, so it does not reach a 5.

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

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

There is no explicit when-to-use guidance or comparison against the obvious alternatives (optimize_quantum_circuit, quantum_optimization_preservation_audit_v1, check_quantum_circuit). The preservation-verification behavior implies a context, but the agent is left to infer when this tool is preferred over its many 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 already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description does add one non-obvious behavioral fact: v0 requests yield a non-durable placeholder while v1 yields a durable Account Core USD quote, which is useful context beyond the annotations, though it does not explain what 'preserved placeholder' means operationally.

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 zero filler, and the v0/v1 contrast is placed early. It is efficient, though the jargon ('preserved v0 placeholder', 'Account Core USD quote') is dense for such a short statement.

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 input schema offers five complex anyOf branches with const schema versions and enums, and an output schema exists, yet the description does not explain which branch applies, whether quoting creates a job, or what the placeholder means. For a tool this structurally complex, the description is far too thin to let an agent 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?

With schema description coverage reported at 100%, the schema carries the field-level burden. The description contributes only an oblique hint tying 'v0/v1' durability to the schema_version branches, and never clarifies product, capability_id, request, or idempotency_key. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description says it returns a quote, and the title already establishes 'Quote an RQM job', but the actual action is never stated in plain language. The v0-placeholder vs v1-durable-quote distinction is a return-value nuance rather than a crisp statement of purpose, leaving the verb+resource largely inferred from the name.

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

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

There is no guidance on when to quote versus when to run a job with the sibling run_buyer_job, submit_quantum_job, or submit_wave_job, nor any prerequisite or sequencing advice (e.g., quote-before-submit). The agent must guess how this fits into the workflow.

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 safety profile is covered. The description adds genuinely useful behavioral context: repairs are conservative, and the tool may instead return an explanation of why no safe repair exists rather than silently rewriting the program. However, it omits that this is a paid operation requiring max_total_price and a payment_rail, which is material for invocation.

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 zero filler; the repair policy and the failure contract are both stated immediately. It is under-specified for such a complex, paid, nested-parameter tool, but the dimension measures waste rather than depth.

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 prose. But for a paid, idempotency-keyed tool with nested request objects and 0% schema description coverage, the one-line description leaves the payment/idempotency contract and all parameter meanings unaddressed.

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 parameters, and the description compensates almost nothing: it never mentions idempotency_key, max_total_price, payment_rail, or the nested request.source field. Only the const value 'conservative' for repair_policy is echoed via the word 'conservatively', which the schema already enforces.

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?

Tautological: description restates name/title.

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 use this tool versus the many adjacent siblings such as quantum_openqasm3_preflight_v1, quantum_openqasm3_repair_v1, or diagnose_quantum_workflow. The 'conservative' policy is implied as the only mode, but the agent is left to infer prerequisites and sequencing 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 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/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 this is a write (readOnlyHint false), safe (destructiveHint false), idempotent, and closed-world. The description adds that a quote must be reserved and that the job is bounded and managed-simulator scoped, which is real behavioral context beyond annotations, though it omits auth, cost, and rate-limit details.

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 beginning with the action and state change, with no filler. It is appropriately terse given the rich schema and annotations.

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?

Core purpose and a key prerequisite are stated, and the output schema plus annotations carry return and safety details. However, the description does not explain the three anyOf schema variants or clarify that capability_id accepts many values beyond managed-simulator-v1, leaving an agent to rely entirely on the schema for that complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description only indirectly signals quote_id ('exact quote') and capability_id ('managed-simulator'), adding little meaning beyond the structured fields.

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 ('submit') and resource ('job'), with scope ('one bounded managed-simulator job') and a prerequisite ('Reserve an exact quote'). This distinguishes it from the batch sibling submit_wave_job via 'one' and from run_buyer_job, though it does not 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?

Signals an implied prerequisite—reserving a quote—which maps conceptually to the sibling quote_job, but never states when to use this tool versus run_buyer_job or submit_wave_job, nor any exclusions. Usage is inferable but not explicit.

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 the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false), so the agent knows this is a non-destructive but mutating/idempotent operation. What the annotations cannot convey is that this is a paid job (max_total_price, payment_rail, idempotency_key are required), yet the description says nothing about cost, billing, quote/run flow, or what 'verified' means. That is a substantial undisclosed behavior for a commercial job-submission tool.

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

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

It is a single short, front-loaded sentence with no filler, which is structurally sound. But because it merely duplicates the title verbatim, the sentence does not earn its place — it conveys no incremental 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 tool with four parameters, nested objects, an enums field, required payment/pricing fields, and a paid job workflow, a one-line title restatement is inadequate. An output schema exists so return values need not be described, but the invocation context — cost limits, idempotency, payment rail, strategy selection — is entirely 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% across four parameters, including deeply nested objects (request.target, request.circuit, request.matrix) and an enum-bearing 'strategy' field. The description only gestures at 'two-qubit block' and 'target-native', which loosely hint at the matrix/circuit and target inputs but explain no field, no enum values, and no pricing semantics.

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?

Tautological: description restates name/title.

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 statement of prerequisites, and no mention of alternatives among the many quantum siblings. The word 'best' implies some ranking among candidate implementations but does not tell the agent when this tool is preferable to compiling or translating a circuit.

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 safety profile is partly covered. The description adds the semantics-preservation promise, which is real behavioural context, but says nothing about the paid nature of the call (max_total_price, payment_rail), what happens on failure, or whether a job is created. For a non-readOnly tool with 0% schema coverage, that is thin.

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 front-loaded sentence with no filler, which is structurally clean. However, its brevity is a symptom of under-specification rather than distillation: it restates the title verbatim and carries no additional operational information.

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

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

An output schema exists, so return values need not be described, but the input side is a nested, multi-required-parameter paid request with zero schema descriptions and the description compensates for none of it. Given the complexity signals (nested objects, payment fields, enum plus idempotency requirement), the definition is not complete enough to call the tool confidently.

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

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

Schema description coverage is 0% for four parameters, three of them required, including non-obvious ones like idempotency_key, max_total_price and payment_rail. The description only gestures at the target framework and even names a value (OpenQASM 3) that is not in the enum, leaving input format, coupling map, basis gates and pricing 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?

Tautological: description restates name/title.

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 mention of alternatives, and no statement of prerequisites or cost implications despite the tool requiring max_total_price and an idempotency_key. The only usage signal is the phrase 'without silently changing its supported semantics', which implies a fidelity guarantee but never says when that matters versus a plain transpile.

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