Affine Earth Math Court Remote

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

With no annotations provided, the description carries the full behavioral burden and does so exhaustively. It discloses the exact status values, refusal conditions, receipt structure (lattice, templates, provenance, words, reading, numbers), the no-model/no-float guarantee, and how numbers follow the source. This is far more behavioral detail than most definitions provide.

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 massive, run-on wall of text with no front-loading or clear structure, making it very difficult to parse. Many sentences are repetitive or overly verbose, and the core information is buried under stylistic jargon. Every sentence does not earn its place; the text is grossly over-specified for its purpose.

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

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

Given the complexity of the tool (multiple status codes, batch handling, sealed templates, exact arithmetic) and the absence of an output schema, the description is remarkably complete. It covers all statuses, receipt fields, refusal conditions, and the distinction between single and multi-target calls, leaving no apparent gap for an agent to call 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 100%, so the schema already documents all five parameters including the exactly-one-of constraint and type refusals. The description largely repeats this information and adds only minor details like the 64 KiB batch limit, which is not enough to raise the score above the baseline. The behavioral aspects of parameters are covered under behavioral transparency rather than adding new semantic meaning beyond the schema.

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

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

The description clearly identifies the tool as an exact translation operation: 'Instant meaning translator on the substrate's own ψ chart' and specifies that it can return one or many projections. The specific verb and resource are present, and the tool is distinguishable from the unrelated sibling tools. However, the purpose is buried under baroque phrasing rather than stated plainly up front.

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

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

The description gives no guidance on when to use this tool versus alternatives, and there are no close siblings to contrast with. It focuses entirely on internal parameter mechanics (exactly one target key, source required) but never states the appropriate context or use case. The agent receives no routing advice.

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

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

With no annotations, the description carries the full burden and does so richly: exact integer arithmetic with no floating point or epsilon, the boundary convention that separation equal to the minima counts as separated, byte-level determinism across 'nine cells', named refusal codes (NOT_MEASURED_SCALED_TIME_BASE_EXCEEDS_EXACT_RANGE, REFUSED_INCOMPLETE_LONGITUDE_SCALE), and the all-or-nothing longitude-scale requirement. This is exactly the behavioral context an agent cannot infer from 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?

Purpose and determinism guarantees are front-loaded in the opening sentence, and almost every sentence adds a distinct constraint. The single dense paragraph is long and packs several concepts (coordinate frame, refusal semantics, tool status) without visual breaks, which slightly taxes scanning, but there is little outright waste.

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

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

For an 8-parameter, no-output-schema tool, the description covers the coordinate frame, the required/optional split, refusal behavior, boundary semantics, and describes what the two return shapes contain (certificate vs violating pair with interval and magnitude). An agent has enough to call it correctly and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3, but the prose adds real meaning beyond the fields: it explains why the minima have no default ('a defaulted separation standard is a verdict about a rule the caller never stated'), how the rational longitude scale stands in for cos(latitude), and that all three scale fields must travel together. The rationale and refusal semantics go beyond the schema text.

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

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

The first sentence names a specific verb (decide/assert) and resource (4D separation over declared trajectories), states the exact decision made (whether any two are ever simultaneously inside the minima) and the two possible outputs (certificate or violating pair with interval and magnitude). No sibling tool overlaps this domain, so the identity is unambiguous.

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

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

It clearly frames the tool as a traffic-analysis instrument and explicitly excludes control use ('never a control tool'), and it tells the caller that supplying only obs_seq yields NOT_MEASURED_OBSERVATION_SET_HAS_NO_TIME_BASE rather than a verdict. It does not spell out preconditions or an explicit when-to-use/when-not checklist against alternatives, but no meaningful alternative exists in this toolset.

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

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

With no annotations, the description carries the full burden and does so well: it states no scalar goes on the wire, that x(Q) is public and never a face, that malformed input returns REFUSED, floats are refused, and the tool is deterministic and does not solve ECDLP. It omits auth/permission or statefulness details, but for a stateless computational verifier this is substantial disclosure.

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

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

The purpose clause is front-loaded, which is good, but the body is a dense run-on of stacked clauses and invented terminology that forces re-reading. Sentences earn their informational load but not their readability.

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

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

There is no output schema, so the description must explain returns, and it names the key outputs and states: pair_verdict WIN/APART, sig_ready true iff WIN, pack_lock ground on a WIN, UNPRESENTED_PAIR, and the REFUSED family. For a complex fused tool this is nearly complete.

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

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

Schema coverage is 100%, so the schema already documents the 4 parameters and their alias labels ('same face as q_hex, old label'). The description restates the q_hex/A roles and reinforces the Q/k alias mapping, but adds little syntax beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific fused operation: take an open key (q_hex), bond a presented private face (A), verify the pair (A*G == Q), and report signature readiness. It also names the sibling laws it fuses ('the same law project_affine_key runs', 'the verify_presented_pair law'), which helps position it against siblings. However, the heavy proprietary jargon ('court', 'face', 'ground') mutes the verb+resource statement, so it lands at a clear-but-not-crisp 4.

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

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

It signals the usage context clearly via 'the pipeline in ONE call' and 'QC-022 fused bond', implying it replaces the separate project_affine_key/verify_presented_pair steps, and it discloses the q_hex-ALONE branch (UNPRESENTED_PAIR). There is no explicit 'use X instead when Y' exclusion, but the conditions distinguishing branches are given.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it names the return outcomes (WIN, CODE_IR_DIVERGED with example message, NOT_KNOWN, REFUSED_* with its trigger conditions), states determinism/statelessness/content-addressing, and honestly scopes the guarantee ('necessary, strong condition ... not full behavioural equivalence').

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

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

Front-loaded with the core question, then proceeds through payload rules, grading, and outcomes in a logical order. It is dense but largely purposeful, with only minor thematic framing ('Code Court's first move') that does not add operational 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 complex, annotation-free tool with no output schema, the description supplies the outcome vocabulary, refusal conditions, and determinism guarantees an agent needs. Remaining gaps are minor: legacy parameter forms and the exact shape of a divergent result are not fully spelled out.

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 a 3 baseline applies, but the description adds real semantic value by insisting the payload is textual LLVM IR (not source) and describing how the inputs may be supplied (left_file/right_file pair or a two-element array). It does not mention the legacy left_ir/right_ir parameters that the schema includes.

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 ('are two implementations equivalent by the exact value multiset of their LLVM IR constants') and elaborates what is graded. It is unambiguous and easily separable from the verify_* quantum siblings, but it never names a sibling or explicitly differentiates itself from 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?

It gives strong preconditions (files must be produced by clang -S -emit-llvm, swiftc -emit-ir, or rustc --emit=llvm-ir) and rough positional framing ('first move'), which implies usage. But there is no explicit when-to-use vs when-not or reference to an alternative sibling tool, so guidance is only implied.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is stateless, that at_seq controls reproducibility versus moving-head reads, and that mined_from is either LLM_WEIGHTS or LLVM_IR. However, it does not state permissions, side effects, rate limits, error behavior, or return shape.

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 three dense sentences that are front-loaded with the resource and source. It avoids filler, though the domain-specific terms are cryptic and the absence of an action verb slightly reduces immediate clarity.

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

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

There are no annotations or output schema, so the description must carry more context than usual. It covers source, provenance, and state semantics well, but does not explain the return structure, pagination behavior, or how this corpus read relates to the many sibling corpus and verification tools.

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

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

Schema coverage is 100%, so the baseline is 3 regardless of description content. The description adds some meaning for at_seq by explaining reproducible reads across cells versus moving-head omission, but it does not elaborate on limit or sector beyond what the schema already provides.

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

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

The description names a specific resource and source: sealed bonds from the Affine.Earth corpus (GAIA_SPATIAL_BOND_WIRES). It does not state an explicit action verb, but the resource is clear enough to distinguish it from verify_* siblings. Sibling differentiation is limited, but the provenance details add useful specificity.

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

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

The only usage guidance concerns at_seq: pin it for reproducibility or omit it to read the moving head. There is no guidance on when to choose corpus_bonds over sibling tools such as bond_presented_key or corpus_coverage. This is parameter-level guidance, not tool-selection 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?

With no annotations the description carries the full burden, and it does disclose two real traits: statelessness and that pinning at_seq yields byte-stable (deterministic) output while omitting it reads the moving head. It omits permissions, any write/read safety statement (implied only by "Census"), and failure/limit behavior, so it is adequate but incomplete.

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

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

Two sentences, purpose front-loaded, no filler, and the stateless/at_seq contract is placed last where it reads naturally. Dense jargon ("sealed bonds", "exact-orbit-closure") slightly reduces scannability but the size is appropriate.

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

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

No output schema and no annotations, so the description must stand alone; it does explain the return shape (counts per lane plus spatial sectors) and the stateless contract, which is the core an agent needs. It leaves key terms ("sealed bonds", "exact-orbit-closure") undefined and gives no error/empty-window behavior, so it is minimally sufficient rather than complete.

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

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

Schema description coverage is 100%, so the schema already defines limit, at_seq and source. The description reinforces the lane filter and adds the determinism framing for at_seq, but adds no syntax or format beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb ("Census") plus resource (corpus over sealed bonds) and enumerates the returned dimensions: per-lane bond count, exact-orbit-closure count, and distinct spatial sectors. Clear on its own, but it never distinguishes itself from the sibling census-like tools corpus_bonds and corpus_coverage.

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

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

The only usage-style guidance is about at_seq ("pin at_seq for a byte-stable census... or omit it to read the moving head"), which is parameter behavior, not when-to-use-this-tool guidance. It gives no condition for choosing it over corpus_bonds or corpus_coverage, so an agent has no routing signal.

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

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

With no annotations, the description carries the full burden, and it actually discloses real traits: the sample is bounded (up to 1024, bound restated in the reply), roster-free cell discovery from written subjects rather than a table, and that the tool follows a moving head and is explicitly not pinnable. It stops short of stating read-only status, permissions, or rate limits, but the disclosed constraints are substantive.

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 purpose is front-loaded, which is good, but the body is a single dense run-on of em-dash fragments and specialized vocabulary that resists quick parsing. It is information-rich but not efficiently readable.

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

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

With no output schema, the description must describe returns, and it does sketch the shape (per-target/per-cell counts, bounded decoded sample, standing message count). For a zero-required, one-optional-parameter query tool that is adequate, but the opaque terminology leaves an agent unsure exactly what a cell or a standing shard cursor means.

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 single cursor_sample parameter is already fully documented in the schema, making the baseline 3 correct. The description's 'bounded decoded sample' phrasing corroborates the bound but adds no new syntax or default beyond what the schema states.

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 resource (fleet-wide mining coverage from the KV cursor bucket) and enumerates what it reports (per-target/per-cell cursor counts, a decoded sample, bond-stream message count). However, the phrasing is dense internal jargon, and it never distinguishes itself from the nearby sibling corpus_bonds, so an agent must guess at the boundary between them.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named even though corpus_bonds sits right next to it in the roster. The 'not pinnable' note is a behavioral caveat, not routing advice.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: the critic is deterministic, requires nine-cell consensus, and reports generative:0 for model-less cells. It also describes the return payload (score 0-1000, integer span/pitch deltas). It omits permissions, side effects, and failure behavior, keeping it from a 5.

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

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

Purpose is front-loaded in the first sentence, which is good. However, the middle sentence is dense and jargon-heavy ('nine cells must reach the same verdict or the fleet's byte-identity is gone'), and the capitalized clause reads as shouting rather than clear exposition.

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

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

No output schema exists, so the description must explain return values, and it does so partially (0-1000 score, integer deltas). But for a 7-parameter tool the description never maps the cryptic h/n/t/w/kind/seed params to their role, and it is silent on the meaning of 'corrections' downstream.

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 seven parameters, setting the baseline at 3. The description adds only indirect hints (span/pitch deltas maps loosely to span_scale_q16; 'framing to grade' hints at t and span), but explains no parameter meaning beyond the schema.

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

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

States a specific verb+resource: 'Grade a rendered frame and return integer corrections.' An agent can tell this critiques/grades a frame rather than generating or verifying one, and no sibling tool overlaps with frame grading. It stops short of distinguishing itself explicitly from ambiguous neighbors like game_frame_meta.

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

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

No when-to-use guidance, no prerequisites, and no named alternative. The determinism/byte-identity constraint is stated as a trait, not as a condition that selects this tool over another. The agent is left to infer when a frame should be critiqued.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: exact rational output (energy_num/energy_den), float rejection with the REFUSED_FLOAT error, and that only the presented configuration is evaluated. It does not explain what 'WIN' means, nor any preconditions or determinism guarantees. Solid but incomplete disclosure.

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

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

Purpose is front-loaded and the description is reasonably sized, but it is dense with undefined jargon and duplicates parameter-format details already in the schema. Every sentence is not maximally efficient, though none is pure 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?

With no output schema and no annotations, the description must cover returns and safety itself; it does specify the energy_num/energy_den return shape and REFUSED_FLOAT error, which is valuable. But 'WIN' is introduced without explanation and there is no coverage of permissions or edge cases, leaving gaps for a computation 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%, so the schema already documents config, constraints, and jordanBondExclusions. The description restates the constraint format (i,j,jnum,jden) and config bit format, adding little beyond the schema; it also never mentions the jordanBondExclusions alias despite the schema declaring it. Baseline 3 is appropriate.

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

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

The description states a specific operation: evaluate ZZ-term 2-local Hamiltonian constraints against a presented bit configuration and return exact energy. It names sibling-related tools (math_court domain qma_2local, verify_vqe_energy) and explicitly says it does NOT search for ground states, which separates it from optimization-style siblings. The heavy jargon ('UUM-8D torus', 'Jordan exclusions') slightly obscures an otherwise clear verb+resource.

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

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

It implies usage via 'given ZZ terms and a presented configuration' and clarifies a negative condition ('no ground state is searched'), which is helpful routing context. However, it never says when to prefer it over the numerous verify_* siblings or math_court, so the agent must infer the selection condition.

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

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

No annotations exist, so the description carries the full burden and does: the 0-7 rung ladder, the ceiling behaviour on toolchain-less cells (SOURCE capped at rung 6, MISS), that sealed bytes come back as an MCP resource blob with a sha256, and that law_checked=false for posted modules. It even documents refusal codes (REFUSED_MISSING_FIELD, REFUSED_ARCHITECTURE_CONFLICT) and the exact accepted architecture string.

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

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

Purpose is front-loaded in the first sentence, which is good, but the body is an unstructured wall of ALL-CAPS tokens with repeated facts (the 'wasm32 is refused' rule and REFUSED_ARCHITECTURE_CONFLICT each appear twice). Given the genuine complexity of the tool the length is defensible, but tightening would materially improve scanability.

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

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

With no output schema and no annotations, the description supplies everything an agent needs: inputs, refusal conditions, the full verdict ladder, the return payload shape (sealed blob plus sha256) and the ceiling behaviour. Nothing required to call it correctly appears to be missing.

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

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

Schema coverage is 100%, so the baseline is 3, and the description still adds meaning beyond the schema: the brief is the single home for target architecture, the verbatim string comparison ('Rust no_std wasm32' accepted, 'wasm32' refused), and the base64 wasm magic requirement for a rung-7 artifact.

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

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

Names a specific verb+resource pair ('Ingest an ARTIFACT INGESTION BRIEF plus the artifact...evaluate it against the laws the brief declares; seal and return the artifact ONLY on the top rung') and is unmistakably distinct from the sibling set of quantum verifiers and corpus tools. The rung ladder and qmt_verdict semantics further pin down what the tool returns.

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

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

Gives concrete when/how context: headless invocation parity across CI runners, curl scripts and editors, the two-call pattern to have Constraints 3/4/5 decided over source, and the when-not note that REFUSED_NO_CRUCIBLE_HOST is unreachable through this tool. It never routes the agent against a named sibling alternative, which is the only gap keeping it from a 5.

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

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

With no annotations, the description carries the full burden and does disclose two real behavioral traits: float matrices are refused and n is capped at 3. It says nothing about the return value, determinism, or cost, which matters for a '#P exact' computation, so the 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 description is short with no filler, but the compression comes at the cost of clarity: the terse jargon ('#P', 'Same law as') obscures meaning, and the size constraint and refusal condition are stacked without clear 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?

For a one-param compute tool with full schema coverage and no output schema, the description covers the input format and two constraints, making it usable. It still omits what the tool returns (the integer value) and any authentication or cost context, leaving a modest 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% and the single matrix param is fully documented in the schema with a format example. The description adds 'matrix is a decimal-string grid,' reinforcing the encoding but contributing little beyond that 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?

The description names the computed object ('exact integer permanent') and a size constraint (n≤3), so an agent can infer it computes permanents of small matrices. However, there is no explicit verb, the '#P' prefix is unexplained jargon, and it does not clearly differentiate itself from the many verify_* siblings beyond a passing reference to the math_court domain.

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

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

'Float permanent refused' implies a constraint on valid inputs, but the description never states when to use this tool versus the sibling verify_* or math_court tools. No prerequisites, no alternatives, no positive usage condition are given.

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

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

With no annotations, the description carries the full burden, and it does disclose a genuinely useful trait: statelessness, replay-admission, and a stable receipt_hash return on identical requests. However it omits side effects (what 'annihilate raw context' actually destroys), auth/identity requirements, and error behavior for a mutation-flavored tool. Useful but incomplete.

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

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

Two sentences with no obvious filler, and the idempotency guarantee is stated prominently. But the opening sentence is an unbroken jargon pipeline that is hard to parse and front-loads metaphor over function, weakening structure for an agent reader.

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?

This is a high-complexity tool (8 params, nested economics object, no output schema, no annotations), yet the description never explains the domain (entity_id/intent semantics), the outcome of a transition, or the receipt beyond a passing mention. The idempotency note is valuable but leaves major gaps for such a complex signature.

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 schema itself is extremely detailed (signature derivation, scf_hex, lattice lanes, refusal behavior), so the description adds essentially nothing about parameters. Baseline 3 applies 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 first sentence is a chain of cryptic metaphors ('Rational S4/C4 lanes -> SCF boundary -> annihilate raw context -> NATS geometry-only turn -> Aristotelian projection') that never states in plain terms what a 'transition' accomplishes or what resource it acts on. An agent cannot tell from this what the tool is for versus the many verify_*/execute_* siblings. It is not a pure tautology, but it stops short of a usable verb+resource statement.

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

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

The only usage guidance is retry semantics ('Safe to retry on a timeout; it is not a second transition'), which speaks to repeated invocation rather than when to select this tool over alternatives. No prerequisites, no when-not-to-use, and no sibling routing (e.g., vs membrane_health or corpus_bonds) are offered.

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

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

With no annotations, the description carries the full burden. It discloses useful behavior: outputs returned (patoshi_expose, shors_qmt_witness, topological_shear), a verdict (jordan_proven), an input constraint ('Floats refused'), and that no k is used for affine_key. Missing: permissions, side effects of 'seal', idempotency, and error/refusal behavior beyond the float check.

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 paragraph with no filler sentences — mode routing, output keys, verdict, and the float constraint are packed efficiently. Density of unexplained jargon slightly harms readability, but no sentence is wasted.

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

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

For an 8-parameter, no-output-schema, no-annotation tool, the description does cover return values and mode routing, which is the right burden to carry. It falls short of telling an agent how the lattice/lock inputs combine or what 'seal' produces in most modes, leaving the calling contract unclear.

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

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

Schema coverage is 100%, so the schema already documents A, B, K, op, kind, q_hex, object and source; baseline is 3. The description adds marginal meaning by tying kind values to modes and mentioning period_r (which is absent from the schema), but it does not clarify the actual semantics of the lattice/lock parameters beyond what the schema already states.

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 header 'Generic court ingest. kind selects the law.' identifies this as a parameterized dispatcher, and the body distinguishes several modes (affine_key, qc_*/qma_*, empty kind, math_court domains). However, it never states plainly what 'expose' does as a tool; the purpose is buried in opaque metaphor ('strobe → emit → seal') that an agent cannot decode without prior domain knowledge.

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

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

It does route to alternatives — 'Named verify_* tools replay a sealed emit' and 'Study domains forward to math_court' — which is genuine when-to-use guidance against siblings. But it never states when to choose expose over, say, lattice_op or project_affine_key, and there are no explicit exclusions or prerequisites beyond 'Floats refused'.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explicitly states 'Stateless; takes no arguments,' which confirms a read-only, no-argument operation. However, it leaves details like response representation, availability, or potential errors unspecified.

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

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

The description is two sentences, front-loads the main purpose, and packs content scoping and stateless/no-arguments traits into concise language without filler.

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

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

Given zero parameters and no output schema, the description adequately conveys what the tool returns: the complete feed set with transports. It does not specify the exact response structure, but for a simple, stateless catalog this is enough to select and invoke correctly.

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

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

The input schema is empty with 0 parameters and 100% schema coverage, so the baseline is 4. The description's 'takes no arguments' matches the schema and adds no unnecessary parameter detail.

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

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

The description identifies a specific resource (all feeds a client can drive a game from) and scopes its contents (corpus lanes by mined_from, live global feeds, transport). It lacks an explicit action verb such as 'list' or 'return', and does not directly distinguish itself from sibling corpus tools like corpus_coverage.

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

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

No guidance is provided on when to use this tool versus alternatives. The description merely defines the catalog; it does not state any conditions, exclusions, or names of sibling tools for routing an agent.

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

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

With no annotations, the description carries the full burden. It usefully discloses 'Stateless' and names the exact parameter tuple that determines the result, plus what the returned score measures. However, it says nothing about side effects, prerequisites, cost, or the meaning of 'C4 span correction' or 'cell', leaving real behavioral gaps.

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

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

Two tight sentences, front-loaded with the operation and its return semantics, with the statelessness constraint at the end. No padding, though the 'C4 span correction' phrasing assumes insider knowledge and costs clarity for no length benefit.

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

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

With no output schema, the description correctly takes on explaining the return value (score 0-1000 over occupancy, spread, contrast, edge quality) and the statelessness contract, which is solid coverage. But with 9 parameters and dense domain jargon, it leaves key concepts (cell, C4 span correction, quality of the frame) undefined for an agent that must invoke it blind.

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 nine parameters and the baseline is 3. The description adds genuine value by naming which parameters (kind, seed, t, n, at_seq) fully determine the result, but leaves h, w, target, and max_iter semantics entirely to the schema.

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

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

States a specific verb+resource ('Run a language-game context') and describes the return payload (state plus a 0-1000 self-evaluation score with C4 span correction), which is more than a restatement of the name. The jargon is dense but the operands and output are named. It doesn't tie itself to a specific sibling like critique_frame, so it stops short of the top tier.

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 tools named, despite a large noisy sibling set including critique_frame and other frame/cell tools. The description implies this is the entry point for running a language-game but gives no decision criteria for choosing it over 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?

No annotations are provided, so the description carries full responsibility for disclosing behavior. It mentions the founder-cell permission but doesn't describe side effects, whether the rebuild is destructive, whether it can be undone, or what happens after invocation. For a 'rebuild' action, this is a significant transparency 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?

Two short sentences deliver the core purpose and the key constraint with no filler. The action is front-loaded and every word adds useful 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 zero-parameter tool with no output schema, the description provides enough to understand the action and the main usage restriction. It leaves the post-conditions and internal effects to inference, which is acceptable for such a minimal interface.

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

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

There are zero parameters and the schema is empty, so schema coverage is effectively 100% and no parameter semantics are needed. The description appropriately adds no parameter details because there are none to document.

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 action ('Trigger a Mac mesh rebuild') and environment ('from the IDE'), so an agent can identify what the tool does. It doesn't explicitly differentiate from sibling tools, but none of the listed siblings appear to perform a mesh rebuild, so the risk of confusion is low.

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 'from the IDE' phrase gives some context for when this is appropriate, and 'Only permitted on the founder cell' imposes a clear access restriction. However, it doesn't explicitly describe when to choose this tool over alternatives or when not to use it beyond the permission constraint.

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

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

With no annotations, the description carries the full behavioral burden and does disclose important behavior: refusals return status REFUSED with a reason under proven, including REFUSED_NO_PAIR and AFFINE_JZ_PARSE, and it notes that a float lane triggers the parse error. However, it does not describe success return shapes beyond the empty-op case, so some behavioral gaps remain.

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

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

The description is dense but front-loads the domain and format before enumerating operations and error behavior. Every sentence carries useful information, though the long operation list could be more scannable if formatted as a structure rather than a running paragraph.

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 complex multifunction tool with no annotations and no output schema, the description covers operations and refusal behavior well, but it does not explain the successful return values for most operations. That omission is significant because there is no output schema to carry the return contract.

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 already 100%, so the baseline is 3. The description adds meaningful semantics beyond the enum names by mapping each operation to its inputs and meaning, e.g. shear uses A against B through K, mask is park only, and B is used for shear, add, sub, mul, distance, and locking_distance.

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

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

The description states a specific resource and verb family: exact integer algebra on UUM-8D lattices, with an explicit string format x0..x7|z and an enumerated set of operations. It also distinguishes itself from the sibling verify_jordan_bond by saying it exposes the same law one operation at a time so callers can inspect intermediate values.

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

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

It clearly routes the caller by explaining that op selects the law, that an empty op returns the list of operations, and that the tool is useful when the caller needs to inspect intermediate values versus using verify_jordan_bond. It does not state when not to use it or outline explicit prerequisites, so it falls short of a full when/when-not/alternatives rubric.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose some traits - decimal strings on the wire, floats refused, 'source' absence refused, the law never reads a clock, out-of-window declines rather than clamps - which are genuinely useful. But for a court that adjudicates dozens of domains it never states whether verdicts are stable/mutating, whether a refusal vs a failure is returned, or what the reach/blocked semantics are across most domains.

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 wall of comma-spliced internals - domain-count chatter, QC-001..019, court-name soup - with no headings beyond 'MINECRAFT:' and no front-loading. Far too little of it earns its place; the catalog enumeration could be replaced by a pointer, and the 'take the count from the catalog, not from any text' aside is repeated in 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?

Given 169 optional params, no output schema, and no annotations, the description does establish the essential meta-contract (empty domain yields the catalog; each court names its REFUSED_NO_INSTANCE fields; decimal strings, no floats) which the schema reinforces. But it is not complete enough for an agent to sit a specific court correctly, and it leaves the return shape and domain routing to be discovered.

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 each of the 169 parameters already has a per-field description naming the reading roles and refusing semantics, so the description largely duplicates rather than extends the schema. It does add cross-cutting rules (decimal strings only, floats refused, empty domain returns the catalog, period_r carries an ECDLP scalar or is empty, never a shear label) which go beyond field-level docs, keeping it at the baseline 3.

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

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

The description opens with 'one tool, every court domain' and then dumps a sprawling enumeration of internal court names (LatticeDomainIntegration, QMA 2-local, QC-001..019, affine_key, minecraft court) that reads as an internal architecture log rather than a stated verb+resource. An agent cannot extract a single crisp purpose, and there is no differentiation from the many verify_* siblings beyond 'math court adjudicates everything'.

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

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

The only usage guidance is that an empty domain returns the catalog and that domain+role+source run the court. There is no statement of when to use this monolithic tool over the specific siblings like verify_shor_witness, verify_qft_phases, or verify_permanent, and no when-not-to-use. The MINECRAFT paragraph implicitly scopes mc_op values but never routes the agent among the 169 parameters.

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

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

The word 'stateless' and the term 'facts' suggest a read-only, no-side-effect informational tool, which is useful because no annotations are provided. However, the description does not disclose output format, data source, freshness, permissions, or what 'cell listen facts' concretely represent. It adds some behavioral context but not enough for full transparency.

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

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

The description is a single, compact fragment with no filler; 'Stateless' is front-loaded and every word contributes. It lacks a main verb and reads more like a label than a sentence, but for a zero-parameter tool this level of brevity is reasonable.

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

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

With zero parameters and no output schema, the description should clarify what the tool returns; it names categories (mode, genesis epoch, subjects, cell listen facts) but not their meaning, format, or how 'health' is represented. The description is likely usable as a simple status probe but leaves key semantics vague.

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

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

The input schema is empty and there are zero parameters, so there is nothing for the description to explain. The zero-parameter baseline of 4 applies, and no parameter information is missing.

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

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

The description identifies the resource ('membrane identity') and lists content categories (mode, genesis epoch, subjects, cell listen facts), which implies an informational/read tool. However, it lacks any verb stating what the tool does (returns, checks, lists), and the name 'membrane_health' is not directly explained. It also does not distinguish this from the large set of sibling tools.

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

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

There is no guidance on when to use this tool versus alternatives such as umc_status or corpus_bonds. No preconditions, exclusions, or alternative routing are mentioned. The absence is neutral rather than misleading.

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

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

No annotations are supplied, so the description carries the full burden. It does add real value by disclosing that data is genuine ('No mock radar'), that an empty result means empty, and that a failed fetch surfaces as 'CURE' - but the meaning of 'CURE' is left unexplained and permissions, rate limits, and read-only status are unstated.

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

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

The purpose is front-loaded and the text is a reasonable length, but it is dense with opaque jargon ('gaiaftcl.radar.*', 'CURE') that a reader cannot decode, so not every sentence cleanly 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?

Given no annotations and no output schema, the description steps in to describe what each lane returns, which covers the return-value burden the absent output schema leaves. It is nearly complete, missing only permission/rate-limit context and a clear failure-code definition.

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

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

Schema coverage is 100%, so the schema already documents all three parameters, including that wallet_hash and c4_invariant_scf are receipt-only and unread by the lanes. The description reinforces lane meaning but adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States specific verb and resource (live NOAA weather) and splits it into two well-defined lanes with named data products (SIGMET polygons, GOES-R X-ray flux, Kp, OVATION aurora). An agent can tell what it returns, but the description never distinguishes it from the closely-related sibling weather.convective_containment, leaving a routing ambiguity.

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

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

The lane semantics imply when to pick 'weather' vs 'space', so usage is inferable but never stated as a rule. There is no explicit when-to-use/when-not guidance and no reference to the overlapping sibling tool, so the agent must guess between them.

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

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

With no annotations, the description carries the full burden and does substantial work: it states scalar multiplication 'closes for every A in [1, n-1]', that the discrete-log path returns verdict CHI_EXHAUSTED with energy_num = n over energy_den = 4096, that the wire status reads MISS, and that 'the court never backfills the face it was asked for'. It discloses the cost-report semantics and the guarantee, though the theatrical framing makes the actual guarantees harder to parse.

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 mode routing is front-loaded, but the description is padded with extended metaphor ('face', 'bond', 'court', 'energy_num', 'shear and period') that costs tokens without adding callable information. Several sentences restate the same mapping multiple times rather than earning their 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?

With no annotations and no output schema, the description must convey returns, and it does name outputs (Q = A*G, x(Q) as public ground, CHI_EXHAUSTED with energy_num/energy_den). But the naming is entangled with in-group metaphor, so an agent cannot cleanly determine the response envelope or success/failure shapes. Adequate but muddled.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds constraints the schema omits: 'Decimal or hex strings; empty means not posted. Floats refused.', plus clarifying that k is the same face as A and Q is the same face as q_hex. These are genuine input-format rules beyond the schema text.

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

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

The description does identify a concrete operation, secp256k1 scalar multiplication/affine projection, and states the two directions ('Post A ... projects Q = A*G' and 'Post q_hex ALONE and the other face is the discrete log'). However, the core purpose is buried under heavy 'court/face/bond' metaphor, and no sibling tool is named to differentiate it from verify_presented_pair or bond_presented_key. It is decipherable but not immediately clear.

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

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

It gives explicit mode routing: post A alone for projection, post both A and q_hex to verify the bond, post q_hex alone to get the discrete-log cost report. That is clear when-to-do-what guidance. It stops short of naming alternatives or exclusions against siblings, so it is not a 5.

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

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

No annotations are provided, so the description carries the full burden and does so well: it discloses that the projected half is verified before return, that operation is bijective and polynomial-time, and input hygiene rules ('decimal strings; empty means not posted; floats refused'). It omits error/response-shape details, keeping it below a 5.

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

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

Front-loads the core contract ('Post ONE half, receive the other') then expands the two cases efficiently. Dense but each sentence contributes; the 'court' terminology is slightly opaque jargon but not wasteful.

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

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

With no output schema and no annotations, the description adequately covers both input modes and what is returned (factor/cofactor vs a), plus verification and formatting rules. Minor gap: it doesn't describe the return value's precise form (e.g., sign/ordering of factor vs cofactor).

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% (baseline 3), but the description adds relational meaning beyond the schema: that factor and cofactor must be posted together, and the algebraic identities the projected values must satisfy (a^2==1 mod N; a==1 mod factor, a==-1 mod cofactor). This clarifies the anyOf shape selection.

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

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

Names a specific operation (Shor twin projection) and states its core behavior precisely: 'Post ONE half, receive the other' with two concrete modes. It distinguishes itself from period-search/discrete-log tools, though it never names a specific sibling by name.

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

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

Gives clear conditions for the two input shapes (post halfPow vs post factor+cofactor) and explicitly states what the tool is NOT for ('does not search for a period and does not derive a discrete log'), which routes agents away from verify_period-like siblings. No explicit when-not-use against the verify_* family beyond that.

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

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

With no annotations provided, the description carries the full burden and discharges it: it opens no app, runs no prover, writes nothing on the cell, reads no clock, and is deterministic ('nine cells return the same bytes for the same record'). It also clarifies that CURE is a ruling rather than an error, which prevents a caller from misreading a non-ok terminal as a failure.

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?

Roughly 340 words for a three-parameter tool, loaded with invented vocabulary ('the court', 'sealed_by', 'franklin', 'the 0.2.6.3 shape') that forces re-reading. The core behavior is not front-loaded; an agent must parse the sign-off predicate before learning what the tool actually consumes and returns.

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

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

With no output schema, the description enumerates the returned fields (terminal, digest, arms_total, arms_ok, failing, missing, franklin, sealed_by, status) and explains the digest's basis. Combined with the input contract and determinism guarantees, an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so the schema already documents date, record, and self_test. The description restates the record's internal arm/shot line structure and the self_test purpose, adding orientation but no syntax beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific action on a specific resource: it grades an Affine IDE release regression record and returns FRANKLIN_SIGNED_OFF when every arm is ok, otherwise CURE. That is distinguishable from the many verify_*/umc_* siblings, though the 'Franklin's sign-off' framing is metaphorical enough that an agent must read several sentences to extract the verb.

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

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

It makes the precondition explicit ('the arms are the caller's measurements') and spells out the exact conditions that yield sign-off versus CURE, including the edge case where a stage arm shows a movie stage on a domain route. It does not name alternatives for grading, but the sibling list contains no competing grader, so the when-to-use picture is effectively complete.

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

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

With no annotations, the description carries the behavioral burden. It states the tool performs exact evaluation, rejects floats, and returns specific outputs (energy_num/energy_den and WIN). It does not disclose side effects or prerequisites beyond input format, but for a read-only calculation this is largely sufficient.

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 multi-sentence but front-loaded with the core purpose, includes a useful example, and avoids filler. It is appropriately sized for the complexity of the 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?

Given no output schema, the description explains the return values (energy_num/energy_den and WIN) and input format. It could clarify what 'WIN' represents and potential edge cases, but for a straightforward calculation tool it is fairly complete.

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

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

Schema coverage is 100% with descriptions for both parameters, so the baseline is 3. The description adds a concrete example and clarifies integer constraints, but these mostly mirror the schema, providing marginal extra value.

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

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

The description clearly states the tool's purpose: given integer couplings and a spin configuration, it returns the exact Ising energy and WIN. It explicitly says it evaluates the presented configuration exactly, distinguishing it from ground-state search or annealing. It also references related tools, aiding differentiation.

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

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

The description implies usage for exact evaluation of a presented spin configuration, noting 'no annealing and no ground-state search.' It mentions equivalence to math_court domain qma_spinglass and verify_qaoa_energy but does not explicitly state when to prefer this tool over those alternatives, leaving some ambiguity.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: the return structure, the fact that 'the caller writes them into its own studies directory; the court writes nothing' (i.e., the tool itself is non-writing), and conditional composition paths keyed to the prompt. It stops short of describing permissions, error behavior, or the edit-list output in detail.

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

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

Purpose and return shape are front-loaded, which is good, but the text is dense and cryptic, with several sentences that only make sense to someone already steeped in the domain. It is neither padded nor genuinely clear, so it sits at minimally viable.

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 no output schema and three parameters, the description does sketch the returned document structure and the side-effect semantics, which is helpful. However, the conditional branches are named only by opaque labels, so an agent without prior context cannot fully predict the output, leaving the definition incomplete for the tool'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?

Schema description coverage is 100%, so the schema already documents study, prompt, and example_usda, making 3 the baseline. The description restates the conditional behavior for example_usda ('bakes the native companion ... or NAMES the shipped companion') and prompt routing, but adds little beyond what the schema descriptions already state.

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 states a specific verb and resource: 'Compose the study document and return it', then names the shape of the returned document (structuredContent.usda, name, layers). That is enough for an agent to know what the tool produces. It does not, however, reference or distinguish itself from any sibling tool, and the heavy domain jargon ('court', 'plague cut', 'native companion') makes the exact artifact unclear.

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?

Guidance is implied rather than explicit: the description maps prompt content to behavior ('A Franklin avatar prompt composes the guidance stage', 'An Iliad scene 02 prompt composes the plague cut'), which hints at when each path fires. But it never states when to choose this tool versus an alternative, and no sibling or prerequisite is named.

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

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

With no annotations provided, the description carries the full burden and does much of it: it discloses the success output (PROVEN_EXACT_IK with the pose), the failure mode (a refusal naming the offending piece or field), the determinism guarantee (zero floats, one Q16 normalization point, byte-identical on arm64 and wasm32), and the write-free nature of the operation. Missing only explicit permission/auth context.

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

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

One sprawling paragraph with multiple em-dash clauses, repeated phrasing ('the court composes...' twice), and cryptic coinages. The most important fact for selection (this is the FORWARD solver, not IK) is present but buried amid jargon rather than front-loaded cleanly.

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

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

There is no output schema, so the description must and does explain the return contract (pose envelope PROVEN_EXACT_IK or a named refusal). For a 3-parameter, nested-free tool whose annotations are absent, this is close to sufficient; only auth/permission context 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 100%, so 3 is the floor, but the description adds genuine semantics the schema does not: pieces rows override the built-in rest chain by id, and absent/empty pieces selects the composed built-in rig. It also explains relative_to_head as camera-free head-relative output. This goes beyond the per-field 'decimal string' examples 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 states precisely what the tool computes: the exact integer forward pose of a fixed seven-piece avatar rig, and explicitly declares what it is not (the IK solver that derives joints from a target pose). That disambiguation is valuable even though the tool name 'evaluate_exact_ik' invites the opposite expectation. The heavy idiosyncratic vocabulary ('court composes', 'sovereign anchor') slightly muddies the core statement.

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

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

It gives real conditional guidance: pieces is optional and when absent/[] the built-in seven-piece rig is used, and relative_to_head switches the reference frame. It also says the target-pose chain is not built here. But it never names an alternative sibling tool or a clean when-to-use rule, so routing depends on the agent parsing dense prose.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses the GRANT CLASS MESH identity requirement and the exact refusal code, statefulness keyed by session_id + node_id, that tau_height/max_turns are decimal strings and floats are refused, and the observed tip/publish payloads (NATS subject, KV key). This is unusually rich behavioral disclosure for a mutation tool.

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

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

The purpose is front-loaded, which is good, but the body is a single run-on sentence packed with domain jargon and an odd 'Measured 2026-09-02 ... CALORIE_GAV_LONG_PLAY' clause that reads like incidental noise. For a tool this complex some length is justified, but the density and one-paragraph structure hurt scannability.

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

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

No output schema exists, yet the description explains the return surface in detail (tip carries session_id, node_id, domain, turn_index, tau_height, torsion as num/den and string, amplitudes, invariant_root_hex, goal_satisfied, stagnant). Combined with auth and statefulness notes, an agent has enough to call and interpret it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the identity alternatives and the decimal-string/no-floats rule, but these largely duplicate what the schema already documents field-by-field, so little net meaning is added beyond the structured data.

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?

Opens with a precise verb+resource+scope: 'Start or advance a Universal Manifold Controller Long Play session for one domain (cinema, aviation, gaming or coding)'. It explicitly distinguishes itself from siblings by naming umc_status (read tip) and umc_resume (continue a sealed session). An agent can tell what this does versus related tools without opening the schema.

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

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

Provides clear routing: use umc_status to read the tip without advancing it, and checkpoint=true to seal the tip for umc_resume. It states the identity prerequisite and the refusal condition. It stops short of fully enumerating when-not-to-use, but the alternatives are named with their selecting conditions.

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

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

With no annotations, the description carries the full burden and meets it: it discloses the GRANT CLASS MESH identity requirement and the exact refusal code (REFUSED_GRANT_MESH_IDENTITY_REQUIRED), the cache-then-NATS resolution order, and a measured observed status (CALORIE_GAV_LONG_PLAY_RESUME). It even lists the returned tip fields, which compensates for the absent output schema.

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

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

Three sentences, front-loaded with the core action and then the identity constraint and the sibling routing. Dense and slightly repetitive (the identity rule appears in both description and schema), but every sentence carries operational information rather than filler.

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

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

For a 7-parameter stateful tool with no output schema and no annotations, the description supplies the missing pieces: identity prerequisites and refusal behaviour, resolution order, and the shape of the returned tip. Nothing an agent needs to invoke it correctly 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 100%, so the schema already documents all seven parameters including enums, identity alternatives and the `direct` flag. The description restates the identity rule and the direct=true behaviour but adds no syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb plus resource ('Resume a Universal Manifold Controller Long Play from its latest sealed tip') and names the backing stores (local cache, then NATS KV bucket UMC_LONG_PLAY). It explicitly differentiates from the closest sibling, umc_direct, so an agent can route between them without opening either schema.

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

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

Gives an explicit division of labour: 'Use umc_direct to create or advance a session; use this to pick up where a previous call, tab or cell left off.' It also explains when the `direct` flag applies (advance one turn after resuming). Both when-to-use and the alternative are covered.

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

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

With no annotations provided, the description carries the full burden. It explicitly states 'Read-only', 'advances nothing', and 'safe to call at any rate', disclosing the absence of side effects and mutation. It also enumerates exactly what information is returned, making the behavior fully transparent.

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

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

The description is a single, dense sentence that front-loads the read-only nature. It lists specific bucket names and subjects, which are necessary for agent understanding. While it is longer than a simple sentence, every element adds value; it could be slightly more structured but is appropriately concise 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?

For a read-only status tool with no parameters and no output schema, the description fully explains what it returns and how it is used. It covers the resources, subjects, and the relationship to sibling tools. There is no missing information an agent would need 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?

The tool has zero parameters, so the description does not need to explain parameter semantics. Schema coverage is trivially 100% with an empty schema. The description adds no parameter-specific details, but none are needed; baseline for zero params is 4.

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

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

The description clearly states it is a read-only status tool that exposes the Universal Manifold Controller tip, KV buckets, Long Play domains, NATS subjects, and the MCP tool surface. It names specific resources and explicitly ties its purpose to discovering what umc_direct and umc_resume act on, distinguishing it from those siblings.

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

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

The description explicitly says 'Use it to discover what umc_direct and umc_resume will act on,' giving a clear when-to-use. It also notes 'takes no arguments, advances nothing, and is safe to call at any rate,' implying it can be used freely. It does not explicitly mention when not to use it or list alternatives beyond the two siblings, but the guidance is clear enough.

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

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

With no annotations, the description carries the full burden and does so: it discloses the exact success token ('iters=1 grover=WIN'), the refusal behavior and its message, that all three fields are required, and that floats are refused. It also states it verifies a presented witness rather than estimating.

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

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

Front-loaded with the purpose and bound, and every sentence adds a distinct constraint or outcome. It is dense and slightly run-on (the example triple is stated twice, and the 'court/law' metaphor is jargon), but no sentence is filler.

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

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

No annotations and no output schema, so the description must cover returns and constraints, which it does: it names the WIN and REFUSED_INSTANCE_BOUND outcomes, the required-field rule, and the type restriction. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real constraint semantics beyond the schema: oracle is a 0/1 string of length exactly 4 with exactly one 1, marked is the 0-based index of that 1, and iterations must be 1. Note a mismatch: the schema says oracle length 2..8 while the description demands exactly 4.

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

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

States a specific verb (verify) plus resource (amplitude amplification / Grover oracle check + presented iterate count), and distinguishes itself from verify_amplitude_estimation by explicitly saying 'no amplitude is estimated.' An agent can route to it without opening the schema.

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

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

Clearly states when the tool applies (N=4 with oracle length exactly 4, one marked index, iterations=1) and when it refuses (any other oracle length is REFUSED_INSTANCE_BOUND). It gives explicit context and exclusion conditions, though it never names verify_amplitude_estimation or verify_grover as the alternative to use.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a real behavioral trait — that non-exact inputs are rejected outright ('Floats refused') and that the fraction must match M/N exactly, implying strict input validation. However, nothing is said about permissions, side effects, or what a pass/fail result looks like.

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

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

Three terse telegraphic sentences, with the subject and the hard input constraint front-loaded and no filler. It is efficient, though the extreme terseness leaves gaps rather than wasting 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?

For a small three-parameter verification tool with a fully described schema, the definition is adequate but thin: there is no output schema and no indication of what verification result is returned or what a failure means. Given the low complexity, the missing return semantics is the main remaining gap.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, including the same M/N equality rule and the example '1/4'. The description largely restates that rule and adds only the float-rejection nuance, which is the correct baseline-3 outcome 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 names a specific verification task ('Amplitude estimation', tagged QC-010), so an agent knows it checks an amplitude-estimation claim rather than computing anything. It does not differentiate from the close sibling verify_amplitude_amplification, which shares the same domain vocabulary, so the agent must infer the split from the names alone.

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

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

There is no statement of when to use this versus the many other verify_* siblings, nor any prerequisite or expected caller context. The only clause offered is a validation rule ('fraction must equal M/N exactly'), which is a constraint rather than routing 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?

With no annotations, the description carries the full burden and does so well: it discloses the WIN/MISS outcome semantics, that nothing is prepared or sampled, and that only bit strings are accepted (floats refused). It stops short of return-format or error-shape detail, but the behavioral contract is clear.

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

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

Front-loads the action and the two inputs, then appends behavioral and input-type constraints. Every sentence does work, though the dense jargon and mid-sentence examples slightly reduce scannability.

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

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

For a two-string verification tool with no output schema, the description covers inputs, the win/miss result, and input-type limits. Only minor gaps remain, such as error behavior for malformed or non-2-bit strings.

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 ab and class. The description restates ab as the two measured bits and class as the claimed class bits, adding little beyond the schema examples, so the baseline 3 applies.

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

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

States a specific verb (certify/verify) and resource (Bell class bits vs the presented two-qubit pair), with a QC label. The clause 'no state is prepared or sampled' implicitly distinguishes it from the execute_* siblings, though it does not name an alternative directly.

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

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

Usage is implied rather than stated: the tool is for checking a witness the caller already holds. There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as the alternative.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses input-validation behavior (all three fields required, separator must be ';', comma lists and floats refused) and the WIN condition, but says nothing about the returned verdict format or outcomes on non-winning input.

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 algorithm and core formula are front-loaded, followed by separator rules, an example, and requirements; nearly every sentence carries information. It is dense and somewhat run-on but appropriately sized for the input complexity.

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 3-parameter verifier with no output schema, the description covers the input contract thoroughly, including separator format, required fields, and a full worked example. The only gap is the expected return/verdict, which is minor given no 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 coverage is 100%, so the schema already documents all three parameters in detail. The description largely restates this (hidden bit string, one answer bit per query, ';' separator) rather than adding syntax or format meaning beyond the schema, so the baseline 3 applies.

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

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

The description names the specific algorithm (Bernstein-Vazirani) and states the exact relation answers[i] = popcount(hidden AND query_i) mod 2, so an agent knows this verifies a BV submission. It is clear but does not explicitly distinguish itself from near-identical siblings like verify_deutsch_jozsa or verify_simon, leaving differentiation to the algorithm name alone.

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

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

It gives a concrete working call and the refusal conditions (comma-separated queries are REFUSED_SHAPE, floats refused), which implies how to invoke it correctly. However, it offers no guidance on when to use this tool versus the many other verify_* siblings, nor on prerequisites or sequencing.

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

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

With no annotations, the description carries the full behavioral burden. 'Floats refused' is a useful piece of input-validation behavior, but there is no disclosure of what 'verify' produces, whether it errors on mismatched class/table, permissions, or any return semantics.

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

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

Three short, front-loaded fragments with no filler. It is efficiently sized, though the telegraphic 'QC-006' token spends a slot without adding meaning for an agent.

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 verification tool with no annotations and no output schema, the description should explain what verification entails and what a result means. Instead it only constrains inputs, leaving the tool's actual behavior and return value 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 100%, so the schema already documents both parameters. The description's '0/1 of length 2 or 4' and 'constant or balanced' largely restate the schema rather than adding format or edge-case detail. Baseline 3 applies.

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

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

The name 'verify_deutsch_jozsa' plus 'QC-006 Deutsch-Jozsa' identifies the resource, and the body clarifies it deals with constant/balanced truth tables. However, the description never states the action in a verb form (verify/check/classify), and 'QC-006' is an opaque code. It does not distinguish this from the many sibling verifiers (verify_simon, verify_bernstein_vazirani) beyond the algorithm 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 statement of when to use this tool versus the near-identical sibling verifiers, no preconditions, and no exclusions. The agent is left to infer usage solely from the algorithm name and input constraints.

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

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

With no annotations, the description carries the burden. It does add useful behavioral facts: the space is not searched, and non-integer/float inputs are refused. It omits what the verification returns, how failures are reported, and any length/exactly-one-1 validation behavior beyond the implicit 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?

Four short clauses, all front-loaded and essentially waste-free; the identifier, constraint, and refusal rule each earn their place. The telegraphic fragment style is efficient but slightly reduces readability.

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

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

For a two-parameter verifier with no output schema and no annotations, the description covers input shape and one refusal case but says nothing about the return value or pass/fail signal, which an agent must know to use a verifier correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates the oracle format (0/1 string length 2..8) and the marked constraint, but adds no syntax beyond the schema, and the phrase 'marked is the unique 1-index' is ambiguous against the schema's explicit 0-based definition.

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 ('Grover presented-oracle verifier') and the 'QC-002' identifier pins the exact variant, which clearly separates it from siblings like verify_amplitude_amplification or verify_deutsch_jozsa. The phrasing is terse and jargony, so an agent unfamiliar with 'presented oracle' still has to infer the semantics.

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?

'Does not search the space' implies this is a checker applied to a supplied oracle rather than a solver, which is the key usage distinction. However, it never states when to call this versus the many other verify_* siblings, nor any prerequisites.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that the check is exact, that the tool never inverts (so it verifies a presented solution rather than solving), that floats are refused, and that n<=2. It stops short of describing what a failed check returns or how errors surface, but the non-obvious behavioral traits are covered.

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

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

Extremely compact and front-loaded, with the identifier first and constraints after; every fragment carries information. The telegraphic style edges toward cryptic, but there is no filler to cut.

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?

It covers input domain and the core operation, but with no output schema and no annotations it should say what a verification returns (pass/fail, witness, error on refusal). For a 3-parameter verifier the return contract is left unspecified, which is 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 description coverage is 100%, so the schema already documents the format of b, x, and matrix in detail. The description only restates the type constraints (integer A, rational b/x), adding nothing beyond the schema. 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?

States a specific verb and resource: it checks A x = b exactly for the HHL algorithm (QC-005). The 'HHL' tag does differentiate it from the many other verify_* quantum-algorithm siblings. However, the acronym is undocumented jargon, so an agent unfamiliar with HHL gets less differentiation value than a plain-language statement would give.

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 and bounded: 'n<=2 integer A and rational b,x' along with 'Floats refused' tells the agent the accepted input domain, so it knows when the call is valid. But it never says when to reach for this tool versus a sibling verifier, nor names any alternative. Implied usage rather than explicit routing.

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

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

With no annotations, the description carries the full burden and does substantial work: it enumerates the three outcome forms (AFFINE_JZ_SHEAR_ZERO, AFFINE_JZ_SHEAR, admitted=false with quarantine_mask), clarifies that quarantine is a decline rather than an error, and warns that float lanes yield REFUSED_FLOAT. It stops short of describing permissions, cost, or limits.

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

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

The core question is front-loaded, which is good, but the description is a dense, jargon-heavy run-on sentence with nested parentheticals. Several clauses (the quarantine aside, the Q-only mode) earn their place, yet the whole is hard to parse on first read.

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 7-parameter tool with no annotations and no output schema, the description supplies the return-value shapes, the refusal mode, and the alternate Q-only path, which covers most of what an agent needs. Gaps remain around required-vs-optional behavior and the role of the legacy creator-hash parameters.

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 seven parameters (A, B, K, q_hex, object, and the legacy creator hashes). The description adds the useful semantic that q_hex/object switches to the Q-only Affine expose and that lanes must be exact integers, but much of the param meaning is redundant with the schema.

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

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

States a specific verb and resource: it decides whether a Jordan-bond equation over eight decimal lanes equals the zero lattice, and names the exact algebraic expression. It is coherent within its own frame, but does not clearly differentiate itself from nearby siblings like corpus_bonds, bond_presented_key, or lattice_op beyond a passing mention of the latter.

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

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

It gives one explicit pointer ('Use lattice_op to inspect one operation of the same law') and describes when the quarantine/admitted=false path triggers, but there is no framing of when to call this vs. the other bond/verify tools, nor any prerequisite 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?

No annotations are provided, so the description carries the full burden. It does disclose a real behavioral trait - that float-based SDP input is refused, forcing rational/decimal-string input - plus the 2x2 size limit. However, it says nothing about what a verification returns, failure modes, or whether an N-representability violation is reported as a boolean or witness.

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?

Very terse, four front-loaded fragments with no filler. The telegraphic style trades clarity for brevity, but every fragment carries information and the purpose comes first.

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

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

With no annotations and no output schema, the description should explain the return value and failure semantics, but it does not. An agent cannot tell what a successful or failed verification yields, nor how 'refused' input is surfaced, leaving a real gap for a validation tool.

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

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

Schema coverage is 100%, so the schema already documents both parameters; baseline 3 applies. The description adds mild context (both are 'decimal strings', rho2 is a num/den rational matrix), but this slightly tensions with the schema, which describes rho2 as num/den rationals while the description calls it a decimal string.

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

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

States a specific verb+resource: verifying QMA N-representability of a 2x2 rational 2-RDM. This is distinct from the amplitude/QFT/Shor verification siblings, though the reference to 'math_court domain qma_nrep' is more of a cross-reference than a clean differentiation. Jargon-heavy but unambiguous about what it computes.

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?

Only weak usage guidance: 'Float SDP refused' implies rational input is mandatory and 'Same law as math_court domain qma_nrep' hints at a relationship with a sibling. There is no explicit when-to-use or when-not-to-use this versus math_court or the other verify_* tools.

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

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

No annotations are provided, so the description carries full burden and does well: it discloses the success outcome (WIN 'a^4 == 1 mod 15'), the failure mode for missing fields (REFUSED_NO_INSTANCE naming the missing field), and rejects floats. It omits what a failed verification (e.g. a LOSE/non-period result) returns.

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

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

Front-loads the mathematical predicate, then constraints, then the worked example and edge behaviors. Dense but no obvious filler; each sentence carries a fact.

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

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

With no output schema or annotations, the description adequately covers inputs, required-ness, the required-on-the-wire proper_divisors, and result strings. Slightly incomplete on the negative-result outcome, but an agent has enough to call it correctly.

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

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

Schema description coverage is 100%, so each of N, a, r, proper_divisors is already documented in the schema, making 3 the baseline. The worked example and the 'must NOT be periods' emphasis add modest value but largely restate the schema.

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

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

States the specific verification predicate precisely: a^r == 1 (mod N), gcd(a,N)=1, and no posted proper divisor being a period (the order claim). This is concrete enough to distinguish it from unrelated siblings, though it does not explicitly route against close cousins like verify_shor_witness.

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?

Implied usage is clear – it validates a *presented* period rather than searching for one, reinforced by 'Does not search for r'. However, no explicit when-to-use/when-not guidance or alternative sibling is named, so an agent must infer the boundary.

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

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

With no annotations, the description carries the full burden and does well: it discloses the return format (WIN or MISS with the exact rational the court computed), states that no estimation occurs, and rejects float inputs. This is meaningful behavioral context beyond parameter documentation.

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

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

Front-loaded with the protocol identifier and the core claim, then parameter meanings, then output and constraints. Efficient and dense, though the parameter-explanation clause repeats schema content.

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 3-parameter verification tool with no output schema and no annotations, the definition covers the operation, input conventions, refusal behavior, and return shape. An agent has enough to invoke it correctly; only error/failure semantics are left implicit.

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 k, m, and phase (including examples and bounds). The description's parameter restatement and examples largely duplicate that schema text, so the baseline of 3 is appropriate.

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

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

States a specific verb (certify) and resource (presented phase equals k/2^m as an exact rational), and names the protocol (QC-011 phase kickback). It is clearly distinguishable from adjacent verify_* tools, though it never explicitly contrasts with the closest sibling, verify_qpe_phase.

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

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

Gives clear usage context: it certifies a claimed rational rather than estimating, and explicitly refuses floats, which tells the agent when this tool is and isn't appropriate. It stops short of naming an alternative tool to use for estimation, so no explicit routing.

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

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

With no annotations, the description carries the full burden and does add real behavioral context: the exact success condition (kG==Q), the REFUSED_NO_INSTANCE error with its detail string for empty calls, and explicit scope limits ('Does not invent a third scalar', 'Does not ECDLP'). It stops short of stating permissions, reversibility, or the full return shape, which keeps it from a 5.

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

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

The text is rambling and not front-loaded: the actual verification rule appears mid-paragraph, interleaved with all-caps slogans, a founder date, and a long quoted error string. Sentences are dense with undefined internal vocabulary rather than earning their place.

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

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

For a six-parameter cryptographic tool with no annotations and no output schema, the description does supply the success condition and one error code, but leaves the return format for non-empty successful calls and any permissions/read-only semantics unstated. Adequate but incomplete for the 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 six faces, making 3 the baseline. The description adds only marginal value, mainly restating the aliasing (A/k, Q/q_hex/object) and the note that hex A may contain 'e' while a decimal point signals a float.

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 does convey the core operation—verifying that a private face (A/k) corresponds to a public face (Q) via 'the one WIN is Face*G == Q_live (kG==Q)'—so a careful reader can extract the verb and resource. However, it is buried under idiosyncratic jargon ('FALSE FACE', 'APART_x_of_Q_is_public_not_a_face', 'never WIN') and never states the purpose in a plain sentence, and it does not distinguish itself from siblings like project_affine_key or bond_presented_key.

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

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

The description explains input requirements ('post at least one face') and the empty-call outcome, but gives no guidance on when to choose this tool over the many verify_* and project_affine_key siblings. There are no stated preconditions or exclusions beyond the anyOf requirement.

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

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

With no annotations, the description carries the full burden and does well: it discloses the return shape (exact integer energy as energy_num/energy_den), the success/failure signaling (WIN vs a MISS naming a malformed instance), and an input-validation rule ('Floats refused'). It doesn't cover permissions or performance characteristics, but for a pure computation tool that is minor.

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

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

Purpose is front-loaded and every clause carries information; there is little filler. The single run-on, dash-heavy sentence is dense and jargon-laden, which costs readability but not size 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?

There is no output schema or annotations, so the description must cover behavior itself, and it does: return encoding, success/miss semantics, refusal behavior, and input formats. What remains unstated (permissions, batching, size limits) is not critical for this deterministic computation.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates the parameter meaning ('edges are couplings i,j,J;... (integers), spins are +1,-1,... one per site'), reinforcing the integer/discrete constraints but adding no syntax or format detail beyond the schema.

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

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

The description states a precise verb+resource: certify the energy of a presented spin string on a presented Ising instance. It draws the boundary explicitly ('the PROBLEM QAOA optimises, not a pulse schedule and not a search'), separating it from execution/search siblings like execute_2local_hamiltonian and verify_vqe_energy.

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

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

It anchors usage by naming sibling conventions ('Same law as route_spin_glass_manifold and math_court domain qc_qaoa') and clarifies what the tool is not (not a pulse schedule, not a search). No explicit alternative-selection rule for other verify_* energy tools, so it stops short of a full when/when-not matrix.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose real input-contract behavior: n is constrained to {2,4,8}, phases must be exact rationals, floats are refused, and no sqrt(n) is accepted. That is useful validation context, but it says nothing about what the tool returns, whether it is read-only, or how failures are reported.

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

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

Four short fragments, front-loaded with the artifact identity, with no wasted prose. The telegraphic style ('No sqrt(n) on the wire') is terse but each clause conveys a constraint.

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

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

With no annotations and no output schema, the description must carry the whole contract, yet it never states what the tool returns (pass/fail, which phase failed) or that it is a verification rather than a generator. For a 3-required-parameter verification tool this is an incomplete contract.

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 each property already documents its format and an example, so the baseline is 3. The description's formula phase[j]=(j*k)/n and the n-in-{2,4,8} constraint largely restate what the schema already conveys, adding little beyond it.

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

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

The description names the artifact (QFT phase table, QC-003) and gives the defining formula, which tells the agent what data is being checked, but it never says the tool verifies/validates it or what a pass means. It is distinguishable by resource (QFT phase table) from siblings like verify_shor_witness, but the action is implied 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 guidance, no statement of prerequisites, and no routing to any alternative among the many verify_* siblings. The agent is left to infer that this applies only to QFT phase tables.

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

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

With no annotations, the description carries the full burden, and it does disclose two behavioral traits beyond restating the name: the exactness requirement, the m<=8 bound, and refusal of floats. However, it omits what happens on failure (error vs. false/negative result), whether the tool is read-only, and any return-shape signal.

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

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

Three short telegraphic sentences with no filler; the core contract ('must equal k/2^m exactly') is front-loaded after the identifier. Nothing to cut.

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 3-required-param verification tool with no annotations and no output schema, the description covers the input contract but omits the failure semantics (what 'refused' means as a response) and the positive/negative result shape, which is the tool's entire purpose.

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% – the k, m, and phase parameters are each documented with constraints and examples in the schema. The description adds the global m<=8 constraint and the exact-equality relation linking the three params, but no syntax or format detail beyond the schema; baseline 3 applies.

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

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

States a specific verb (verify) and resource (QP phase), and pins the conceptual scope to 'QPE' (quantum phase estimation). It does not name a sibling or differentiate itself from the many other verify_* tools, but the domain specificity keeps it from being vague.

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

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

The description implies usage through the exact-equality contract ('Presented phase must equal k/2^m exactly'), but never states when to use this vs. e.g. verify_phase_kickback or verify_qft_phases among the crowded verify_* family, nor does it state prerequisites or exclusions.

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

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

With no annotations, the description discloses important behavior: WIN when equal, MISS naming the true count, verification of a presented witness, and no amplitude-based counting. It also states floats are refused, though it omits side-effect/auth details that are likely irrelevant for this verifier.

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

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

The description is compact and front-loads the core criterion before constraints and outcome. Minor telegraphic fragments like 'Floats refused' and the QC identifier are not wasteful but keep it slightly abrupt.

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

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

No output schema exists, but the description explains the WIN/MISS outcome and that MISS names the true count. Inputs and validation constraints are covered sufficiently for a two-parameter verifier, though exact MISS formatting could be clearer.

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

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

Schema coverage is 100%, so baseline is 3. The description adds that oracle marks 1s, count is a claimed decimal string, and floats are refused, improving semantic precision beyond the schema's examples.

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 and resource: certify that count equals the number of 1s in the presented oracle string. The QC-015 quantum-counting label and exact counting relation distinguish it from sibling verify_* tools without needing to open 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?

Implies usage by saying a presented witness is verified, but does not explicitly say when to use this versus other verification tools. It gives constraints such as length 2..8 and float refusal, yet no alternatives or exclusions are named.

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

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

With no annotations the description carries full burden, and it does meaningful work: it discloses the input format contract (decimal strings, floats refused) and the return behavior (WIN or MISS naming the reached vertex). It doesn't cover error/edge behavior or permissions, but for a pure verifier this is solid disclosure.

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

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

Front-loaded with the algorithm identity and rule, then input/output contract. Dense but every clause contributes; only minor redundancy between the description's format note and the schema's own descriptions.

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 stateless verification tool with 3 required params and no output schema, the description supplies the correctness rule, input format, and result format, which is enough to invoke it correctly. Only the absence of explicit alternative-routing guidance keeps it from a 5.

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

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

Schema coverage is 100% and each parameter already documents its type and range (start/end 0 or 1, steps >= 0). The description restates the same format constraints without adding syntax or edge-case meaning beyond the schema, so baseline 3 applies.

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

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

States a specific verb (certify/verify) plus a precise resource: a quantum walk on the two-vertex cycle C2, with the exact parity rule. An agent can immediately tell this is the C2-walk verifier and distinguish it from the other verify_* algorithm tools without opening the schema.

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

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

The description explains the domain rule that governs correctness but gives no explicit when-to-use/when-not or routing against the many sibling verify_* tools. Usage is implied by the algorithm named, which is the minimum viable level.

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

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

With no annotations, the description carries the full burden and does meaningful work: it declares float inputs are refused, states the tool only certifies rather than searching, and names the returned components. The 'verdict is the measured jordan_proven tag' rule is real behavioral disclosure, though several terms remain unexplained.

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

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

The opening certifier sentence is front-loaded well, but the later sentences are dense chains of internal jargon with low information density for an outside agent. Nothing is padded, yet the structure is hard to parse in one read.

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

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

For a six-parameter tool with no annotations and no output schema, the description compensates by naming the required witness quartet, the optional Q expose, the returned components, and the float-rejection rule. Remaining gaps are the cryptic tag names rather than missing call-critical facts.

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

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

Schema description coverage is 100%, so every parameter already carries its own description with the same equations, making the description's restatement of a^2==1 (mod N), gcd, and factor*cofactor=N largely redundant. It adds only the decimal-string presentation and the q_hex/object aliasing, which the schema also already shows.

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 (certify/verify) and resource (QC-001 Shor witness) and even explicitly says what the tool does NOT do ('Does not find a period'), which separates it from verify_period. However, the second half collapses into opaque internal vocabulary (patoshi_expose, shors_qmt_witness, topological_shear) that does not sharpen the purpose.

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?

'Does not find a period' implies the sibling verify_period is the alternative for period-finding, but the routing condition is never stated explicitly. No guidance on when to supply (N, halfPow, factor, cofactor) versus the optional q_hex/object envelope.

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

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

No annotations are provided, so the description bears full disclosure burden, and it does well: it states the exact success/failure reporting (WIN vs MISS naming the failing relation), that the mask is presented and never recovered, and that float inputs are refused. It omits any return payload format or error/auth details, but the described behavior is unusually concrete for a no-annotation 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?

Front-loaded with the core purpose, then the three verification relations, then edge constraints. Dense and jargon-heavy but each clause earns its place; 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?

With no output schema and no annotations, the description appropriately covers the accepted inputs, the verification relations, and the outcome semantics (WIN/MISS). Only minor gaps remain (no explicit return payload shape, no permission/prerequisite context), which is reasonable for a self-contained cryptographic verification tool.

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

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

Schema coverage is 100% (baseline 3), but the description adds non-redundant semantic constraints tying parameters together: x != y, x XOR y == mask, f(x) == f(y), and equal-length bit strings. These cross-parameter relations are not in the schema and materially guide correct invocation.

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: certify a presented collision for Simon's algorithm (hidden mask). The described relations (x != y, x XOR y == mask, f(x) == f(y)) make the operation concrete. It doesn't explicitly name which sibling (e.g., verify_presented_pair, verify_shor_witness) it differs from, but the algorithm-specific naming still separates it from the crowd of verify_* tools.

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

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

Gives the win condition (WIN when all three relations hold, MISS naming the failing relation) and a constraint (floats refused, mask is presented not recovered). These imply when the tool applies, but there is no explicit when-to-use/when-not-to-use guidance relative to the many verify_* siblings.

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

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

With no annotations, the description carries the full burden. It does disclose two useful behavioral traits beyond the schema: the equality assertion semantics ('decoded must equal sent') and an input-validation rule ('Floats refused'). However, it says nothing about what happens on mismatch (error vs. false result) or the shape of the verification outcome, and no output schema exists to fill that 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?

Three short, front-loaded sentences with no filler; the invariant and the type rule each get one line. The bare 'QC-017' code label is slightly opaque but costs almost nothing.

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 simple two-parameter equality-check tool, the description covers purpose, invariant, and type validation. It stops short of describing failure behavior or the verification result, which matters for a verify_* tool with no output schema and no annotations.

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

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

Schema description coverage is 100%, so the schema already documents both required string parameters with examples. The description adds only the type restriction ('Floats refused'), which is marginal since the schema already types both as strings. Baseline 3 is appropriate.

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

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

Names the specific protocol (Superdense coding / QC-017) and states the exact invariant being verified: decoded 2 bits must equal sent 2 bits. This clearly separates it from quantum siblings like verify_teleport or verify_bell_measurement, though the action verb ('verify') is only implied by the tool 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 use this versus the many other verify_* primitives, no stated prerequisites, and no exclusions. Usage is only inferable from the protocol 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?

No annotations exist, so the description carries the full burden. It usefully discloses an input-validation trait ('Floats refused') and defines the relational invariant being verified, but says nothing about return values, pass/fail signaling, or error behavior on mismatch. Partial disclosure for a tool with no annotation cover.

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

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

Three tight fragments, front-loaded with the operation identity and the defining constraint. Nothing is padded. The only cost is the opaque 'QC-016' identifier, which consumes a slot without explaining itself.

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 verification constraint is fully specified, which is the core need for a 3-param check tool. However, with no output schema the description never indicates what a verification returns (boolean, error, or confirmation string), leaving the agent to guess the outcome contract.

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 per-parameter examples, so the baseline is 3. The description adds genuine cross-parameter semantics not present in the schema: the constraint that bob, alice, and corrections are related by XOR over exactly 2 bits. That is real added meaning beyond the individual field docs.

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

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

The description names the specific resource (quantum teleportation reconstruction) and defines the exact check performed: 'bob = alice XOR corrections on 2 bits.' An agent can tell this apart from other verify_* siblings by topic, though no sibling is named explicitly. The purpose is concrete, not a tautology.

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 is given, and no alternative among the ~20 verify_* siblings is referenced. Usage must be inferred entirely from the name and the XOR constraint. This is a real gap in a dense verification family.

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

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

With no annotations the description carries the full burden, and it does disclose the key behaviors: the outcome semantics (WIN when the pair matches, MISS otherwise) and an input-validation rule ('Floats refused'). It does not describe permissions or side effects, but for a pure verifier the result and rejection behavior are the traits that matter.

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 purpose is front-loaded in the first clause and the four short sentences each carry a distinct fact (scope, constraint, outcome, input rule). It is dense with jargon but not 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?

There is no output schema, and the description partially compensates by describing WIN/MISS results. But 'MISS naming it' is ambiguous and key terms like 'sealed pair' are left undefined, so an agent has an incomplete picture of what the response actually reports without domain knowledge.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds a meaningful constraint not fully captured by the schema: q and r are 'claimed integers' and floats are refused, clarifying that the decimal-typed string params must be integral. The word parameter's sealed-corpus context is reinforced.

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 (certify/verify) and resource (the Eisenstein pair (q, r) for a cited word), and explicitly scopes it against alternatives with 'the sealed corpus; not a group scan'. An agent can distinguish it from sibling verifiers, though the heavy domain jargon ('sealed pair', 'Eisenstein') adds cognitive load.

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

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

It constrains usage by limiting word to the two cited words Z2_a2b or Z2_abAB and warns it is not a group scan, which is useful negative scoping. However, it never names which sibling tool (e.g. verify_presented_pair) to use instead when the input falls outside this narrow case, leaving the when-to-use routing implicit.

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