Affine Earth Math Court Remote

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

With no annotations, the description carries the full burden and mostly delivers: it discloses determinism, the no-model guarantee, null-return for unheld texts, that source_lang 'auto' is refused, batch limits (up to 64, 64 KiB), and named refusal statuses. This is unusually rich failure-mode disclosure, though it omits permissions/rate/return-format basics.

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, but the body is a dense run-on packed with undefined coinages ('flash', 'cell', 'ψ charts', 'sealed template of projections') that consume space without adding usable meaning for an agent. The information is cluttered rather than concise.

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

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

Given no output schema and no annotations, the description does explain return behavior (ordered texts plus RENDERED/PARTIAL/REFUSED status), failure modes, and input limits, which is largely sufficient for this 5-parameter tool. Minor gaps remain around preserve_register scope and target_lang constraints.

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 each parameter, establishing a baseline of 3. The description adds batch ordering ('returns texts in order') and reiterates the required/refused constraint on source_lang that the schema already states, so it adds only marginal meaning.

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 clause 'Renders text from one natural language into another' states a specific verb and resource, so an agent can identify this as a translation tool. However, the core purpose is immediately buried under opaque jargon ('flash', 'ψ charts', 'mined discrete manifolds'), and there is no differentiation from siblings. Clear but not clean.

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

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

The description never states when to use this tool versus an alternative, nor any task-level context beyond 'translation'. It documents internal fallback mechanics ('until then the pair's sealed template ... answers') rather than actionable usage guidance, and gives no exclusions or 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 provided, the description carries the full burden of behavioral disclosure. It discloses no floating point and no epsilon, that equality with the minima counts as separated, deterministic byte-for-byte output, exact rational longitude scaling, and that missing coordinate scales are reported honestly rather than presented as ground distance. This is deep, non-obvious behavior that an agent needs to know before invoking.

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 four dense sentences with the purpose front-loaded and no wasted filler. The only deduction is for the cryptic phrase 'nine cells return the same verdict from the same bytes,' which is likely intended to convey determinism but may confuse an agent more than it helps.

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

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

For a complex tool with no annotations and no output schema, the description covers purpose, exact arithmetic behavior, output alternatives, coordinate-frame policy, and usage boundary. It does not define the structure of a 'separation certificate' or enumerate all refusal paths, which are partially left to the schema, so a small completeness gap remains.

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 all parameters already have explanatory descriptions. The main description adds the exact-integer and rational-time execution model and the caller's responsibility for longitude scale, but it does not add per-parameter semantics beyond what the schema already provides. 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 opening sentence names the exact operation: decide whether any two declared trajectories are ever SIMULTANEOUSLY inside stated separation minima, and return either a separation certificate or the violating pair with exact interval and magnitude. This is specific, distinguishes it from the unrelated quantum/verification siblings, and leaves no ambiguity about what the tool 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?

The description provides clear usage context: 'Civil FAA/ICAO framing; a traffic-analysis instrument, never a control tool.' This tells an agent when it is appropriate and explicitly rules out a control context. However, it does not name any alternative tool or formalize when a sibling should be preferred, so it stops short of full when-vs-alternative 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 provided, the description carries the full behavioral burden, and it delivers: it explicitly states the tool is deterministic, does NOT perform ECDLP (no scalar search), refuses malformed input (REFUSED family) and floats, and details the computational law (scalar multiplication A*G, total, no search). For an unannotated tool this is genuinely useful behavioral disclosure, only slightly hampered by the cryptic vocabulary.

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 dense wall of run-on, jargon-packed sentences ('q_hex ALONE answers UNPRESENTED_PAIR - no scalar on the wire; x(Q) is reported as ground because it is real and derivable, and it is PUBLIC, never a face'). While information-rich, it is not front-loaded or structured for rapid parsing; the esoteric terms force an agent to decode multiple domain-specific concepts before acting.

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

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

Given the tool's complexity (a multi-step pipeline), the absence of an output schema, and zero annotations, the description covers many aspects: input handling, result families (UNPRESENTED_PAIR, pair_verdict, sig_ready, pack_lock), edge cases (malformed, floats), and determinism. Yet its completeness is undermined by unexplained specialized vocabulary — an agent unfamiliar with 'court', 'face', 'ground', and 'pack_lock' cannot fully exploit the information provided.

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%, but the description adds real value beyond the schema: it clarifies that q_hex is the primary/required input (the schema lists no required params yet q_hex's description says 'required'), that Q is an alias for q_hex and k is an alias for A ('same face'), and specifies format constraints (04-prefixed uncompressed pubkey hex; A as 64-hex or decimal). This resolves ambiguity the schema alone leaves open.

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 clear operation at a high level — fuse an open key (q_hex) with an optional private face (A) and produce a verification verdict (UNPRESENTED_PAIR, pair_verdict WIN). It references siblings project_affine_key and verify_presented_pair by name, aiding differentiation. However, the purpose is buried under dense esoteric jargon ('court', 'FALSE FACE', 'pack_lock', 'ground', 'face'), making it hard for an agent to grasp the core verb without 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?

The description gives an internal branching rule: q_hex alone answers UNPRESENTED_PAIR; providing A triggers pair verification via the verify_presented_pair law. It also references that the same law project_affine_key runs, hinting at sibling relationships. But it never explicitly tells the agent when to choose THIS tool over verify_presented_pair or project_affine_key — the selection guidance is implicit, not stated.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does so thoroughly: it discloses statelessness, content-addressed determinism, the possible result leaf states (WIN, CODE_IR_DIVERGED, NOT_KNOWN, REFUSED_*), and the exact comparison criterion. It even tells the reviewer that re-checking is done by re-digesting rather than re-reading a diff.

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 and front-loaded: within the first sentence an agent knows what the tool compares and what payload to send. Each later sentence adds a distinct decision-relevant detail—outcomes, determinism, and scope limitation—without padding or significant repetition.

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

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

For a tool with no output schema, no annotations, and nested-object inputs, the description covers the input contract, all result signs, determinism, and equivalence semantics. The legacy left_ir/right_ir fields are covered by the schema, and the description is complete enough for an agent to call this tool without further inference.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the payload model: two whole source files can be supplied as left_file/right_file or as a two-element files array, and the result echoes those same files. This links the parameter mechanics to the output structure in a way the field descriptions do not.

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 and resource: it decides whether two implementations are equivalent by comparing the exact value multiset of their LLVM IR constants. It also explicitly distinguishes itself from full behavioural equivalence, which separates it from the many verification-style siblings in the tool list.

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 positions the tool as 'The Code Court's first move' and as a 'necessary, strong condition for the numeric kernels,' giving clear context for when it applies. It explicitly says it is not full behavioural equivalence, but it does not name a specific sibling tool as the alternative for that broader comparison.

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 and explicitly discloses that the operation is stateless and that at_seq enables reproducible reads across cells. It does not describe the return shape or side effects beyond read intent, but for a read-only corpus accessor this is reasonably 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?

Two sentences with no filler: the resource, provenance values, statelessness, and the key invocation choice are all front-loaded and each clause earns its place.

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

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

For a tool with zero required parameters and full schema descriptions, the description covers the essential context: what is returned, provenance, and reproducibility semantics. It is slightly incomplete because it never clarifies what 'sealed bonds' are or how sector filtering relates to them, but it is adequate for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value on top by detailing what at_seq means behaviorally ('reproducible across cells' vs 'moving head'). It does not elaborate on limit or sector, but their schema descriptions already cover syntax and bounds.

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 starts with a concrete resource ('Sealed bonds from the Affine.Earth corpus (GAIA_SPATIAL_BOND_WIRES)') and names the data provenance values ('mined_from is LLM_WEIGHTS or LLVM_IR'), making the tool's function immediately identifiable. It is not a tautology and the specific corpus/bond resource separates it from the sibling corpus_* 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?

It gives clear operational guidance by explaining how to get deterministic reads ('pin at_seq') versus reads of the moving head, which is a concrete context for invocation. It does not name alternative tools or state when not to use corpus_bonds, so it falls short of 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 of behavioral disclosure. It states statelessness and byte-stability, which are meaningful behavioral traits, but it does not explicitly confirm read-only/no side effects, auth requirements, or rate limits. For a census tool mutation is unlikely, but the safety profile is not explicit.

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 wasted words: the first fronts the purpose and output shape, the second gives parameter behavior and a statelessness guarantee. Every phrase 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?

Without an output schema or annotations, the description must explain return values and behavior itself; it does sketch the returned counts and sectors and stateless behavior. But it omits details like default window size when limit is absent, the exact response format, and error semantics, leaving an agent with some uncertainty.

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 valuable semantics: it explains the window concept tied to limit, the pin-vs-moving-head behavior for at_seq, and enumerates the lane values corresponding to source. This goes beyond the schema's bare property descriptions without restating them unnecessarily.

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 this is a census of what the corpus captured over a bounded window of sealed bonds, enumerating the per-lane counts and spatial sectors. This is a specific purpose that distinguishes it from generic query tools, though it does not explicitly contrast with sibling tools like corpus_bonds or 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?

It provides operational guidance on using at_seq to pin a byte-stable census versus omitting it to read the moving head, which is useful. However, it does not mention when to prefer this tool over siblings or any exclusion conditions, so tool-selection 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 provided, the description carries the full transparency burden and does a reasonable job: it discloses the bounded nature of the decoded sample, that the bound is stated in the reply, that the tool follows a moving head, and that it is not pinnable. It does not cover error behavior, authentication, or side effects, but for a read-oriented coverage view the key behavioral traits are disclosed clearly.

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 efficient: it front-loads the main purpose, then lists the concrete output components in a compact sequence, and closes with the two key limitations. Some jargon like 'KVs cursor bucket' and 'bond stream' is not expanded, but every sentence contributes distinguishing 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 low-complexity tool with one optional parameter and no output schema, the description is largely sufficient: it enumerates the output categories, explains the discovery mechanism, and states the bounded and non-pinnable behavior. It does not describe the reply format or failure modes, but those are less critical given the tool's read-like purpose and the schema's parameter documentation.

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 schema already documents the single optional parameter cursor_sample as a decimal string up to 1024 and notes the bound appears in the reply, so schema description coverage is 100%. The tool description adds no extra meaning to this parameter, which keeps this at the baseline rather than higher.

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 producing fleet-wide mining coverage from the KV cursor bucket, with specific countable outputs: shard cursor counts per target/cell, a bounded decoded sample, and bond stream message counts. It also distinguishes itself by noting it is roster-free and not pinnable. However, there is no explicit action verb like 'returns' or 'reports,' so it stops short of the clearest possible formulation.

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 useful context about when this tool is appropriate: it is roster-free, discovers cells from subject writes rather than a table, and follows the moving head. It also states explicit limitations ('not pinnable, and says so'), which helps an agent avoid using it when pinned or roster-based data is needed. It does not name alternative sibling tools or give an explicit 'use this tool when...' rule, so it misses the top score.

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 of behavioral disclosure. It reveals that the critic is deterministic, that consensus among nine cells is required, that cells report generative:0, and that the output is a score0-1000 plus integer span/pitch deltas. The failure consequence is cryptic, but the tool's core behavior is unusually well disclosed.

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 and output details are front-loaded and compact, but the middle sentence is dense and cryptic ('nine cells', 'fleet's byte-identity is gone', 'generative:0') without adding clear, actionable invocation guidance. It is short, but not every phrase 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?

The description explains the output format and some behavioral constraints, but it leaves the meaning of parameters such as h/n/t/w/kind largely unexplained and does not state what happens if consensus fails. For a tool with no annotations and no output schema, a little more framing around inputs and failure behavior would make it 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 high at 86%, so the schema already provides at least terse descriptions for most parameters. The description does not add substantial per-parameter meaning; it only mentions 'span/pitch deltas' in the output context. Thus it sits at the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Grade a rendered frame and return integer corrections.' It also states the scoring range (0-1000) and integer return type. It does not explicitly differentiate from sibling tools like the verify_* family, so it stops short of a 5.

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

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

The phrase 'Grade a rendered frame' implies when the tool should be used, and 'deterministic, not a model' hints that it fits critic/consensus work rather than generative or model-based evaluation. However, there is no explicit when-to-use or when-not-to-use guidance and no mention of alternative sibling tools, leaving the choice largely to inference.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns exact rational energy, evaluates only the provided configuration, does not search for ground state, and refuses floats (REFUSED_FLOAT). However, it does not explain what 'WIN' means, what errors may occur beyond float refusal, or any side effects or prerequisites. This is moderate disclosure but leaves key behavioral details ambiguous.

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 paragraph that is not front-loaded. It begins with obscure jargon ('QMA 2-local Hamiltonian, sealed as exact rational Jordan exclusions on the UUM-8D torus') before stating the actual action. It repeats the 'same law' reference and includes unnecessary qualifiers. The structure makes it harder to parse quickly and could be reorganized to lead with the clear action and parameter formats.

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 description lacks a clear output specification: it mentions returning energy_num/energy_den and WIN but does not describe the format or structure of the result. It also omits error handling (beyond float refusal), any required permissions, and the meaning of 'WIN'. Given no output schema and the complexity of the tool, an agent would likely need additional context to reliably parse the result. This is incomplete for a tool with no output schema.

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

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

The schema has 100% coverage with brief descriptions, but the tool description adds significant syntax details: it explains constraints as 'i,j,jnum,jden;...' and config as 's0,s1,... bits', and clarifies that jordanBondExclusions is an alias for constraints. This goes beyond the schema and helps an agent construct valid inputs. Since coverage is high, a baseline of 3 applies, but the added syntax guidance raises it to 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 states a specific action (evaluate a presented configuration) and resource (2-local Hamiltonian energy) and clarifies it returns exact energy and WIN. It distinguishes itself from search tools by noting 'no ground state is searched' and links to sibling tools. However, the opening jargon ('sealed as exact rational Jordan exclusions on the UUM-8D torus') obscures the core purpose and may confuse an agent unfamiliar with the 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?

The description implies usage by stating it evaluates a presented configuration rather than searching, and notes it follows the same law as math_court qma_2local and verify_vqe_energy. This gives context but does not explicitly state when to prefer this over alternatives or when not to use it. The exclusion is only about floats, not about choosing between sibling tools.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses the full verdict ladder, the optional-target_architecture conflict behavior, the headless API-layer enforcement, and the exact no-toolchain failure mode with its consequence (no qmt_verdict). This goes far beyond a generic 'evaluate' statement and tells the agent exactly what to expect.

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 long and dense, but almost every sentence carries behavioral information that an agent needs for correct invocation. It is front-loaded with the core action, then layers rationale, conflict handling, verdicts, and failure modes. A small amount of redundancy with the schema (e.g., target_architecture conflict) could be trimmed, but the structure is logical and purposeful.

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?

Despite having no output schema and no annotations, the description is remarkably complete. It enumerates every result type, explains when a refusal occurs instead of a normal verdict, and specifies what happens to qmt_verdict in the no-toolchain case. An agent can predict the tool's behavior across normal, conflict, and environment failure paths without needing extra documentation.

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 adds only marginal semantic value: it reiterates the four-section brief structure and repeats the 'REFUSED_ARCHITECTURE_CONFLICT' behavior already present in the target_architecture schema description. It does not explain the artifact parameter or target_architecture format 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 first sentence states an explicit verb and resource: 'Ingest an ARTIFACT INGESTION BRIEF plus the artifact an agent generated for it; evaluate it against the laws the brief declares; seal and return the artifact ONLY on the top rung.' This clearly distinguishes the tool from the many verify/evaluate siblings by focusing on brief-driven artifact sealing rather than quantum or math verification.

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 clear context for when this tool is used: whenever a generated artifact must be evaluated and sealed against a brief. It does not name alternatives or explicit when-not conditions, but it does disclose an environmental constraint ('A host with no toolchain returns REFUSED_NO_CRUCIBLE_HOST'), which helps a caller decide whether to invoke it in a given environment. No competing tool exists among siblings, so the lack of an explicit alternative is acceptable.

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

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

With no annotations, the description carries the full behavioral burden. It discloses exact integer semantics, the n≤3 limit, and float refusal, which are valuable. But it does not state the return format, failure behavior, or how an invalid matrix string is handled, and the 'Same law as...' clause is opaque without domain 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?

Three terse sentences front-load the operation and constraints with no redundant restatement of the schema. The 'Same law...' clause is jargon, but it is compact and does not bloat the description.

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

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

For a one-parameter compute tool with no output schema, the core constraints are present. However, an agent still lacks a concrete return-type statement, an example, and failure behavior, and the domain-law reference assumes external knowledge. Adequate but not fully 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 baseline is 3. The description adds useful constraints by calling the matrix a decimal-string grid, forbidding floats, and capping n≤3, but it does not clarify required status (schema says required=[]) or provide a concrete delimiter example.

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

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

The phrase '#P exact integer permanent' specifies a precise computational task, and 'n≤3' sets the scope, distinguishing it from the other execute_* siblings. No explicit verb like 'computes' appears, but the meaning 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 conveys when-not conditions: 'Float permanent refused' and 'n≤3'. However, it neither names an alternative tool nor explains when to prefer this over execute_transition or execute_2local_hamiltonian, so routing guidance is only implicit.

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 so substantively: it states idempotency, statelessness, replay admission, identical receipt_hash, and timeout-retry safety. It leaves the side effects of `annihilate raw context` unspecified, but this is still strong behavioral disclosure compared to typical descriptions.

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, front-loads the pipeline, and devotes only two additional sentences to idempotency and retry semantics. A plain-language summary would help, but as written every sentence earns its place and there is no padding.

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

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

The schema and referenced signing algorithm are rich, and the description explains idempotent retry well. However, there is no output schema and the description only mentions `receipt_hash` without defining the full return contract. For a complex 8-parameter protocol with 14 intent values and an undefined `bond_status`, the context remains incomplete.

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

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

The free-text description adds no parameter-level meaning, but the input schema already documents 6 of 8 parameters, including a very detailed `client_signature`. The under-documented `intent` (enum-only) and `bond_status` are not compensated for, so the description stays at a baseline-3 level without improving parameter understanding.

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

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

The description names a concrete membrane pipeline (`Rational S4/C4 lanes -> SCF boundary -> annihilate raw context -> NATS geometry-only turn -> Aristotelian projection`) but never explains in plain terms what a transition is or what observable result it produces. It avoids being a tautology, yet an agent without domain vocabulary cannot reliably tell what this tool accomplishes, and it does not contrast itself with sibling `execute_*` 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?

The description gives one actionable retry rule (`Safe to retry on a timeout; it is not a second transition`) and clarifies idempotent replay behavior. However, it never states when to choose this tool over alternatives or what input conditions warrant calling it, so the primary usage 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 and provides meaningful detail: the strobe → emit → seal act, the affine_key return values, period_r's constraint ('never a shear label'), and rejection of floats. The terms themselves are obscure, but the disclosure goes beyond a mere existence statement.

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 but densely packed with unexplained technical terms ('UUM-8D reconvergence', 'add-law turn', 'patoshi_expose'), making it hard to scan. It is not overly long, but the structure is a single dense block rather than clearly separated behaviors or modes.

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 8 optional parameters, no output schema, and no annotations, the description leaves many open questions: what each of A, B, K, op, and source do, what 'seal' means, and what the general return shape is for kinds other than affine_key. The routing and some constraints are covered, but the overall operational contract is incomplete.

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

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

Schema coverage is only 38%, yet the description does not explain A, B, K, op, or source, and it references 'period_r' and 'Q' that are not present in the input schema. It adds some context for kind and implicitly for q_hex/object, but fails to compensate for the low schema coverage across most parameters.

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

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

The description identifies a specific operation ('court ingest') with a dispatch mechanism ('kind selects the law') and distinguishes itself from siblings by stating that verify_* tools replay emits and study domains forward to math_court. However, 'generic court ingest' remains somewhat vague and relies on domain-specific jargon like 'strobe → emit → seal' to carry meaning.

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 concrete selection guidance: affine_key, qc_* / qma_*, empty kind returns catalog, and explicitly routes named verify_* tools to replay a sealed emit and study domains to math_court. It stops short of an explicit 'when not to use' list, but the alternatives and their conditions are identifiable.

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 transparency burden and does a solid job. It explicitly discloses statelessness and determinism—'(kind, seed, t, n, at_seq) fully determine the result'—and specifies the score range and evaluation components. It does not detail the 'state' structure or error behavior, but the side-effect profile 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?

The description is compact and front-loads the core action and deterministic contract in two sentences. The only notable jargon is the unexplained 'C4 span correction', but the overall structure has no padding.

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

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

The description gives good score semantics and determinism, but the returned 'state' is not described and there is no output schema to compensate. For a domain-specific tool with nine parameters and no annotations, this leaves some ambiguity for an agent.

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 high (89%), so the description does not need to re-document every parameter. It adds meaningful semantic information by naming the five determinative parameters, though the roles of h and w are left unexplained.

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

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

The description names a specific action and resource ('Run a language-game context') and clearly specifies the two output components: the state and a self-evaluation score. The score's range and composition are also stated, though it does not explicitly differentiate itself from a sibling like critique_frame.

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 intended use case is implied: obtain a deterministic language-game frame state and its self-evaluation. However, there is no explicit guidance on when to prefer this tool over alternatives or when not to use it.

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 burden, and it discloses meaningful behavior: decimal-string lane parsing, float lanes landing in AFFINE_JZ_PARSE, missing/wrong-lane operand refusal via REFUSED_NO_PAIR, and the empty-op list behavior. It does not explicitly state purity/no side effects or the response envelope, but the refusal and parsing disclosures go well beyond a minimal definition.

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 and generally well-structured, front-loading the lattice format and then moving through operations, input constraints, refusals, and sibling relationship. The 'measured 2026-09-02' timestamp is mildly extraneous, but the rest of the text earns its place for a tool with 12 operations and 5 parameters.

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

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

The description covers input format, supported operations, refusal modes, and the relationship to verify_jordan_bond, which is substantial. However, with no output schema and no annotations, it does not explicitly describe what each operation returns (e.g., boolean vs lattice vs distance integer), leaving the caller to infer return shapes from operation names and parentheticals.

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 real semantic value: it explains the UUM-8D lattice representation, the lane-wise nature of add/sub/mul, what shear means, the 0-255 homology mask for park, and the refusal mapping for malformed operands. This goes beyond the schema's per-parameter descriptions.

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

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

States a specific resource ('UUM-8D lattices'), the exact lattice format, and enumerates every operation the tool exposes. It also distinguishes itself from the sibling verify_jordan_bond by saying it is the same law but exposed one operation at a time for inspecting 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?

The description gives clear operational context: op selects the law, an empty op lists ops, and the tool is a stepwise counterpart to verify_jordan_bond so callers can inspect intermediate values. It names the relevant sibling alternative, though it does not explicitly enumerate when-not-to-use conditions beyond that contrast.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose genuinely useful facts: empty domain returns the catalog, decimal-string-only wire format ('Floats refused'), affine_key's triple return, and period_r's ECDLP-scalar-or-empty rule. But it omits the general return format, pagination, error behavior beyond schema mentions, and side effects for a tool with no 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?

The description is compact and not wordy, but it is a single dense run-on paragraph with heavy nested parentheses that is hard to parse. It front-loads the tool identity and core action, yet the structure buries key behavioral facts inside the jargon. Efficient but not well-organized.

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

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

For a 152-parameter tool with no output schema, the description is far too thin. It does not explain the domain/role/source routing model in plain terms, gives no worked example, and offers no overview of LatticeDomainIntegration or how an agent should pick a domain. The schema carries most of the burden, but the description still fails to make the tool navigable.

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 each of the 152 parameters individually described (which domain/role reads it), so the description need not repeat parameter details. The description adds only the wire-format note ('Decimal strings on the wire. Floats refused'), which is useful but minor. 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 names a specific function ('runs LatticeDomainIntegration') across a long list of domains, and gives concrete behavior hints for affine_key and period_r. However, the purpose is buried under opaque jargon ('patoshi_expose', 'shors_qmt_witness', 'topological_shear') that an agent can't map to a coherent action, and it never explains what 'court' conceptually produces. It is more than a tautology but less than a clear enunciation of 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?

There is no guidance on when to call math_court versus the many verify_*, project_*, or execute_* siblings. The only routing hint is 'Empty domain returns the court catalog', which tells an agent how to discover courts but not when this tool is the right one instead of e.g. verify_shor_witness. No when/when-not/alternative guidance is provided.

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

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

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?

With no annotations provided, the description carries the full burden and adds valuable behavioral context: it explicitly states 'No mock radar', meaning results are real, and defines failure semantics ('a failed fetch is CURE'). It also mentions output components like altitude tops and movement vectors. The meaning of 'CURE' is not expanded, but the core trust and failure behavior is disclosed.

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 dense sentences with no fluff. The main purpose is front-loaded, lane-specific outputs are separated clearly, and the behaviora note about mock data and failures earns its place. Every sentence contributes.

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 description explains the primary lane parameter and gives a good sense of the returned data, but there is no output schema, so return format is not specified. Two of three parameters are left undocumented, and no guidance is given for what happens if lane is omitted despite being non-required in the schema. The core use case is clear, but completeness has clear gaps.

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

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

Schema coverage is only 33%, so the description must compensate for the undocumented parameters. It does explain lane in detail, mapping each value to its output. However, wallet_hash and c4_invariant_scf are completely unexplained both in schema and description. An agent cannot infer their purpose or whether they are needed, which is a significant gap.

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

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

The description clearly states what the tool does: it returns live NOAA weather data for an aviation radar lane, with distinct outputs for lane=weather (convective SIGMET polygons) and lane=space (GOES-R X-ray flux and aurora). The level of specificity distinguishes it from general weather tools and from the sibling weather.convective_containment, even without naming alternatives.

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

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

The description gives clear context for choosing between the two lane values, explaining exactly what each returns. It does not explicitly mention alternatives or exclusionary conditions relative to sibling tools, but the internal lane routing is well specified. This is more than implied usage, though not a full when-to-use vs alternatives guide.

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 discloses key behaviors: that posting q_hex alone returns a COST report, not a claim of impossibility; that the court never backfills the requested face; that x(Q) is public; and that floats are refused. This is substantial behavioral disclosure, though the metaphor (court, faces, bond) may obscure some details for an agent.

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 overly long and uses elaborate metaphor ('court', 'faces', 'bond', 'wire status') that makes it harder to parse. While it is organized in sentences, it is not front-loaded with the most critical information; the essential behavior is buried in prose. It could be significantly condensed while preserving 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?

The tool is complex (cryptographic projection with three modes) and has no output schema, so the description must explain return behavior. It does so for each mode: returns Q for scalar mult, verifies the bond, and returns a verdict with energy_num for discrete log. It also notes the probe limit and the MISS wire status. This is fairly complete, though the metaphor might leave ambiguity about exact output structures.

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 has no descriptions for the four string parameters (A, Q, k, q_hex). The description compensates well by explaining that A is the private face, k is accepted as the same face, q_hex is the other face, and Q is presumably the public point. It also clarifies decimal or hex formats and the empty-string convention. This adds meaning beyond the bare 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 states that this is an affine key projection on secp256k1, and explains the three usage modes (scalar multiplication, verification, and discrete log cost reporting). It uses specific verbs like 'project' and 'verifies', and names the resource (secp256k1). However, it does not explicitly differentiate from sibling tools, though none appear directly similar.

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

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

The description explains when to use each input combination (post A, post both, post q_hex alone), which provides clear usage context. However, it never mentions alternatives or when NOT to use this tool, and there is no explicit routing to other tools. The guidance is implied through the modes but not explicit about 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 must carry behavioral disclosure and it does: verification before return, polynomial-time bijection, no period search/discrete log, decimal-only input, empty-means-not-posted, and floats refused. It does not explicitly discuss side effects or edge-case behavior when both halves are supplied, but the main behavioral profile is clearly conveyed.

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 not bloated; the front-loaded 'Post ONE half, receive the other' immediately communicates the contract. The only slight deduction is for cryptic jargon such as 'QC-001b' and 'court', which carry a little less value than the mathematical 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 four-parameter tool with no output schema and no annotations, the description covers the transformation, verification, complexity, and input format. It could be more explicit about the required presence of N in both modes and about what happens if both halves are posted, but an agent can infer the intended call pattern from the stated math.

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

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

Schema coverage is 0%, yet the description gives every parameter concrete meaning: N is the modulus in the congruences, halfPow is a nontrivial square root a, and factor/cofactor are the CRT pair satisfying a == 1 mod factor and a == -1 mod cofactor. It also defines value constraints and the empty-string convention, far exceeding the bare string 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 concrete bidirectional projection between halfPow a and factor/cofactor modulo N, with explicit math formulas for both directions. It also distinguishes itself from period-finding/discrete-log tools by saying it 'does not search for a period and does not derive a discrete log.'

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 two explicit call modes: post halfPow to get factor/cofactor, or post factor/cofactor to get a, and explains the exact congruence conditions for each. It does not name sibling alternatives explicitly, but the mode-based usage and the 'does not search for a period' exclusion give the agent enough contextual 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 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 provided, the description carries the full behavioral burden and does reasonably well: it states zero floats, one Q16 normalization point, byte-identical results on arm64 and wasm32, and a specific anchoring scheme. It does not disclose error behavior, validation of the chain, or whether the operation is purely computational, but it provides strong numerical and determinism transparency that goes beyond a generic 'evaluates IK' statement.

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, with two sentences that both earn their place: the first defines purpose and output, the second adds important numerical and cross-platform guarantees. Some jargon such as 'sovereign anchor' and 'Q16 normalization point' is terse but not redundant; there is 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?

There is no output schema and no annotations, so the description must cover behavior and returns. It does explain output units and determinism, but it omits details such as error handling for invalid chains, the meaning of 'relative_to_head' beyond the schema gloss, frame axis conventions, and whether the report covers all pieces or only the requested piece_id. For a fairly specialized tool, these are notable gaps.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters and their decimal-string types. The description adds only high-level context about composing frames and reporting poses; it does not deepen the meaning of 'pieces', 'piece_id', or 'relative_to_head' beyond what the schema provides. 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 names a specific resource ('declared piece chain'), a specific operation ('exact integer inverse kinematics'), and a concrete output ('each piece's pose in whole milli-units'). It clearly distinguishes this from the many quantum verification and simulation sibling tools by specifying a deterministic, integer-based robotics computation.

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

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

The description implies when to use the tool: when exact, float-free, cross-platform reproducible IK results are needed. However, it does not explicitly state when not to use it, mention alternatives, or describe selection criteria relative to other tools. Usage context is present but only through inference from the exactness and determinism claims.

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 fully carries behavioral disclosure. It details required identity (REFUSED_GRANT_MESH_IDENTITY_REQUIRED), output tip fields, statefulness, decimal-string requirement, float refusal, checkpoint sealing, and NATS publish side effects. This is exemplary 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 long but each sentence earns its place. It front-loads the core purpose, then layers constraints, outputs, and side effects. While dense, the structure is logical and there is 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?

For a highly complex tool with no output schema and no annotations, the description is remarkably complete. It covers error cases, data types, statefulness, side effects, and refers to sibling tools. An agent has nearly everything needed to invoke it correctly.

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

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

Schema covers 100% of parameters, so baseline is 3. The description adds meaning beyond schema by clarifying that tau_height and max_turns are decimal strings (floats refused), that node_id is the caller identity, and that session_id controls resume vs restart. These enrich 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 specific verb ('Start or advance'), a precise resource ('Universal Manifold Controller Long Play session'), and explicitly names the domain constraint. It distinguishes itself from siblings by referencing umc_resume and umc_status, so an agent can tell them apart without opening 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?

Provides explicit usage guidance: 'Use umc_status to read the tip without advancing it' and implies umc_resume for continuation. It also clarifies when to start vs advance via session_id semantics. No ambiguity about alternatives.

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

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

With no annotations provided, the description carries the full burden and meets it: it discloses the identity requirement (GRANT CLASS MESH) and the exact refusal code, the return shape (same as umc_direct with listed fields), the storage order (local cache first then NATS KV), and the effect of 'direct'. This goes well beyond typical descriptions, covering error conditions, side effects, and output format.

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

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

The description is dense but every sentence adds value—purpose, direct flag, auth, return shape, and sibling distinction are all covered. It is slightly verbose with the 'Measured 2026-09-02' detail, but the structure is logical and front-loaded with the main purpose, so it earns a 4 rather than a 5.

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

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

Given the tool's complexity (auth, storage, return format, sibling routing) and the lack of annotations and output schema, the description covers all essential aspects: it explains the error code, return shape, storage behavior, and usage distinction. Nothing an agent needs 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 all parameters are described in the schema. The description adds minimal parameter-specific nuance beyond the schema; it mentions the 'direct' flag's effect but that is already in the schema. Baseline 3 is appropriate given full schema coverage and no significant additional explanation.

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

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

The description clearly states the tool resumes a UMC Long Play from its latest sealed tip for given identifiers, and explicitly differentiates from umc_direct by specifying that umc_direct creates/advances a session while this picks up where a previous call left off. The verb and resource are specific and 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 explicitly names the alternative (umc_direct) and the condition for choosing it, plus explains the 'direct' flag as equivalent to one umc_direct call. This provides clear when-to-use vs when-not-to-use guidance with no 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 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 full burden. It discloses that it verifies a presented witness, does not estimate amplitude, rejects floats, and returns two verdicts (inner Grover and iteration check). It also explains the N=4 iteration rule. This is comprehensive for a read-only verification tool, though it doesn't mention side effects (likely none).

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 each sentence earns its place. It front-loads the tool's identity and scope, then details constraints and return values. No wasted words, though it could be slightly more compact without losing meaning.

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 adequately explains what the tool does, what it returns, and the special rule for N=4. It is self-contained enough for an agent to call it correctly, though it doesn't define N explicitly, which is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds the logical constraint that iterations must be 1 at N=4, which is extra meaning beyond the schema, but it doesn't clarify what N is or how it relates to oracle length. The added value is marginal; 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 verb ('verify') and resource (amplitude amplification via Grover oracle check), and distinguishes itself from siblings like verify_grover and verify_amplitude_estimation by explicitly saying 'no amplitude is estimated' and describing its specific scope (oracle + iteration check). The purpose is unambiguous.

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

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

The description gives constraints (floats refused, iterations must be 1 at N=4) but does not explicitly state when to use this tool versus alternatives. It implies this is for verifying a specific QC-009 witness, but does not name sibling tools or provide exclusion criteria. Usage context is implied, not explicit.

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

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

With no annotations, the description carries the behavioral burden and does disclose two meaningful behaviors: exact equality is enforced and floats are refused. It does not state what happens on success/failure, whether normalization occurs, whether the operation is read-only, or what output is returned, so transparency 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?

Two tight sentences front-load the identifier and the core rule. There is no filler, no restatement of the tool name, and each sentence contributes new 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 verification tool with no output schema and no annotations, the description is too sparse. It omits return/result semantics, error behavior, the acceptable format of fraction, and clarification of optional parameters. An agent would likely need to guess or experiment 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 0%, so the phrase 'fraction must equal M/N exactly' is the only semantic link for the parameters: it implies M and N are the numerator/denominator and fraction is the value to compare. This is useful but incomplete because it does not specify the expected string representation, integer constraints, or why all parameters are optional 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 tool name supplies the verb ('verify') and resource ('amplitude estimation'), while the description sharpens the purpose with a concrete invariant: fraction must equal M/N exactly and floats are refused. This helps distinguish it from verify_amplitude_amplification and other verify_* siblings, though the description lacks an explicit standalone verb phrase.

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: this tool is for verifying amplitude estimation results where an exact rational fraction M/N is expected and float inputs are not allowed. However, it gives no explicit when-to-use guidance, no exclusions, and no comparison to alternatives such as verify_amplitude_amplification, leaving the agent to infer routing from context.

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

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

No annotations are provided, so the description must carry the burden. It explicitly states that the tool verifies a presented witness and does not prepare or sample state, and it defines outcome behavior (WIN/MISS). It also adds input constraints ('Bit strings only; floats refused'). This is a strong disclosure, though it does not detail the exact return format or edge-case handling.

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

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

The description is concise, front-loaded with the core purpose, and each sentence adds value. It packs purpose, parameter meaning, behavioral constraints, and outcome logic into three efficient sentences with no redundancy.

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

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

For a simple two-parameter verification tool with no output schema and no annotations, the description covers the essential aspects: purpose, parameter roles, input constraints, and outcome semantics. It does not explicitly state what happens with missing parameters (both are optional), but that is a minor gap given the simplicity.

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, but the description adds meaningful context by explaining that 'ab' are the measured bits and 'class' are the claimed class bits, which clarifies the roles beyond the schema's terse definitions. This extra explanation helps an agent correctly assign values.

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 function: certify that presented Bell class bits match a two-qubit pair. It uses a specific verb ('certify') and resource ('Bell measurement'), and clarifies it is a verification tool, not a state-preparation tool, which distinguishes it from potential siblings like verify_amplitude_amplification or verify_presented_pair.

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

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

The description implies when to use it (verifying a Bell measurement claim) and explicitly notes that no state is prepared or sampled, which sets expectations. However, it does not explicitly name alternative tools or state when not to use it, so there is no direct exclusion guidance beyond the general purpose.

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 disclosure burden. It supplies a precise verification condition and states that floats are refused, which is meaningful behavioral information. However, it does not say what the tool returns on success or failure, whether it only checks consistency, or what side effects or errors may occur.

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 very short and front-loads the essential mathematical relation. Each sentence adds information: the algorithm identifier, the verification equation, and a type constraint. The cryptic 'QC-007' prefix and the terse 'Floats refused' are compact but not fully self-explanatory.

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 annotations, no output schema, and three undocumented parameters, this description is incomplete. The formula is useful, but an agent still lacks guidance on input format, return value, error behavior, and how verification outcome is communicated. It is a minimally viable core spec rather than a complete callable 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?

The schema provides no parameter descriptions and coverage is 0%, so the description must compensate. It does relate hidden, queries, and answers through the formula, clarifying that hidden and query_i are bitwise operands and answers is a list of parity bits. Yet it does not explain string encoding, bit order, optionality, or how queries are represented, leaving important format details unresolved.

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 plus 'Bernstein-Vazirani' and the explicit formula 'answers[i] = popcount(hidden AND query_i) mod 2' identify the algorithm and the core relation being verified. It distinguishes this from the many other verify_* siblings by algorithm name and mathematical condition, though it never states the verb 'verify' directly in the description.

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 about when to choose this tool over the many sibling verification tools, nor any prerequisites, exclusions, or context for use. The algorithm name implies a domain, but there is no explicit 'use this for Bernstein-Vazirani verification' or statement of when not to use it.

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 must disclose behavior itself. It does mention that floats are refused and constrains table length and class values, but it does not describe what the tool actually does, whether it is read-only, what invalid inputs produce, or what the verification outcome means.

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

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

The description is short and front-loaded, with each sentence contributing a distinct constraint. It earns its compactness, though 'QC-006' is cryptic without external context and the telegraphic style omits a clear functional statement.

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

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

For a quantum verification tool with no annotations, no output schema, and empty parameter descriptions, the description is incomplete. It explains input domains but not the verification criterion, the expected result, error behavior, or how to distinguish this from closely related verify_* siblings.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful constraints: table is a 0/1 value of length 2 or 4, class is constant or balanced, and floats are refused. This is more than the bare schema provides, though the exact string format of 'table' is still somewhat ambiguous.

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

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

The description identifies the tool as 'QC-006 Deutsch-Jozsa' and names the relevant inputs (table, class), so an agent can infer this verifies a Deutsch-Jozsa classification. However, it never states an explicit action such as 'verify that the table matches the given class' or what result is produced, relying heavily on 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?

The algorithm name and parameter constraints imply when this tool is relevant, and 'Floats refused' gives some input guidance. But there is no explicit statement about when to use this over the many sibling quantum verification tools, nor any mention of alternatives 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 provided, the description carries the full behavioral burden. It usefully discloses that the tool does not search and refuses floats, which are meaningful behavioral constraints. However, it does not mention side effects, return value/format, or error behavior for invalid inputs such as malformed or missing oracle strings.

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

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

Three short sentences deliver the tool's role, parameter constraints, and behavioral caveats with no filler. The most important categorization ('verifier') is front-loaded, followed by concise parameter semantics and a clear non-search disclaimer.

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 tool, the definition covers the inputs and one key behavioral detail. Still, with no output schema and no annotations, the description should state what the verifier returns (e.g., boolean valid/invalid) and how it handles invalid or missing arguments. The agent can infer some of this from the name and constraints, but it is not explicit.

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 provides bare string types with no descriptions, so the description is the only semantic source. It adds crucial meaning: oracle must be a 0/1 string of length 2..8, and marked is the unique 1-index. It would be stronger with an explicit format for marked (e.g., integer within 1..8) and requiredness, but it substantially compensates for the 0% schema coverage.

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

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

The description clearly identifies this as a Grover 'presented-oracle verifier' and explains the input roles: oracle is a 0/1 string and marked is the unique 1-index. It also distinguishes the tool from a search operation by explicitly saying it does not search the space. However, it stops short of stating the precise verification criterion (e.g., whether it asserts that the oracle has exactly one marked position and that index matches marked).

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 statement 'Does not search the space' gives an explicit exclusion: this is not a tool for executing Grover search. That is useful routing information. But no positive condition is given for when to select this verifier over the many sibling verify_* tools, and no alternative tool 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, the description bears the full behavioral burden. It discloses that the operation performs an exact equality check, explicitly does not invert the matrix, and refuses float inputs. This is meaningful behavioral context. It stops short of describing return values or error handling for refused inputs.

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?

Five short fragments, each adding distinct information: identity, constraints, operation, non-inversion, and input policy. There is no filler, and the most important scope-limiting facts are front-loaded.

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 and no annotations, the description omits the return behavior of the check, the required string format for matrix and rationals, and the outcome when invalid inputs are passed. It conveys overall intent well but is not fully actionable for an agent making an automated call.

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

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

The input schema provides only parameter names and types with zero descriptions. The description compensates by mapping matrix to integer A and b/x to rational values, and by adding the n<=2 restriction. Yet it leaves the string encoding of rationals and the matrix representation unspecified, so parameters remain only partially explained.

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

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

The description specifies a precise verb ('Checks'), a clear resource ('HHL'), and an exact mathematical condition (A x = b). It also distinguishes itself from solvers by stating 'Does not invert', which separates it from siblings that might perform inversion or transformation.

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 provides clear applicability constraints: n<=2, integer A, rational b and x, and 'Floats refused'. This gives an agent concrete guidance about when inputs are acceptable. However, it does not explicitly name alternative tools or state fallback options when these constraints are violated.

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 of behavioral disclosure. It details all return outcomes (AFFINE_JZ_SHEAR_ZERO, AFFINE_JZ_SHEAR, and the admitted=false with quarantine_mask), explicitly states that the quarantine is 'not an error,' describes the integer-only requirement with REFUSED_FLOAT, and explains the Q-only expose with its specific return identifiers. This is comprehensive transparency beyond what any structured metadata could offer.

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 paragraph but is well-structured: it leads with the core decision, then lists return values, then the optional mode, then constraints, and finally the sibling pointer. Every sentence contributes information, though the length is higher than strictly necessary. The front-loading of the main purpose is effective.

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 verification tool with multiple modes, error states, and optional parameters, the description covers everything an agent needs to call it correctly: the exact mathematical law, all return values, the non-error quarantine behavior, the integer constraint, the alternative Q-only mode with its outputs, and a pointer to a sibling for finer inspection. No output schema exists, but the description lists the returned identifiers explicitly, so the agent knows what to expect.

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 parameter is already documented in the input schema. The description adds meaningful context by explaining the mathematical relationship between A, B, and K (the formula) and clarifying that q_hex/object are aliases for the same optional path. However, it largely repeats the schema's field descriptions (e.g., 'decimal lattice') rather than adding substantially new semantics. Thus a 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 opens with a precise verb and resource: 'Decide the UUM-8D Jordan bond J_Z' followed by the exact equation. It clearly states the tool's job (deciding whether a lattice expression equals zero) and distinguishes itself from sibling lattice_op by saying 'Use lattice_op to inspect one operation of the same law.' This gives an agent a clear identity and separation from 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 provides explicit context for when to use the tool (to decide the bond) and points to lattice_op as an alternative for inspecting a single operation. It also explains the optional Q-only mode for q_hex/object. While it does not explicitly say 'use this when you need to verify the bond,' the phrasing makes the purpose unambiguous, and the alternative is named with its 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?

With no annotations, the description bears the burden of behavioral disclosure. It adds useful behavior: refusing float SDP inputs and requiring decimal strings, and it ties the tool to a known law domain. However, it does not state the return format, possible errors, or side effects, leaving an agent partly to infer behavior from the tool name.

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

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

The description is short and every sentence carries weight: subject, input representation, refusal behavior, and law identity. It is front-loaded and free of filler, though somewhat telegraphic and jargon-dense.

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

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

There is no output schema and no annotations, so the description must carry more context. It provides enough to know the input encoding, but not what the tool returns, how failures surface, or how it relates to sibling verification tools. For a niche topic like QMA N-representability, this leaves significant gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that rho2 and n are string-based and clarifies the 2×2 rational nature, but it does not add much beyond the schema. Its phrase 'decimal strings' is slightly ambiguous against the schema's 'num/den rationals', though not fundamentally misleading.

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 object and scope: QMA N-representability of a 2×2 rational 2-RDM, and anchors it with 'Same law as math_court domain qma_nrep', which helps distinguish it from the many verify_* siblings. It does not explicitly say 'verify' or 'check', but that verb is already in the tool name, so the intent is 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?

There is no explicit guidance on when to choose this tool over alternatives or when not to use it. The note 'Float SDP refused' is an input constraint rather than a routing cue, and the math_court reference does not clarify whether math_court is an alternative or a dependency.

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 discloses the key behaviors: the congruence condition, the gcd condition, the proper-divisor minimality check, the fact that r is not searched for, and that floats are refused. It does not state return type or invalid-input handling, but the core behavior of a pure verification tool is well specified.

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

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

Three short sentences convey the formula, the proper-divisor constraint, the no-search caveat, and an input restriction without filler. The most important semantic is front-loaded and every clause earns its place.

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

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

For a tool with no annotations, no output schema, and zero parameter descriptions in the schema, the description covers the normal verification logic but leaves significant gaps: return behavior, invalid-input handling, and whether N/a/r are mandatory. An agent can construct a typical call but is undersupplied for edge cases and expected responses.

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 formula maps N, a, and r to their roles in the verification and gives proper_divisors clear meaning as the minimality-check input. It also marks proper_divisors as optional. However, string formats and the requiredness of N/a/r are left ambiguous, especially since the schema lists no required parameters.

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

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

The description specifies an exact mathematical predicate: verify that r is a presented period satisfying a^r == 1 (mod N) with gcd(a,N)=1, and that optional proper divisors are not themselves periods. It clearly identifies the action (verify) and the resource (a period candidate), and explicitly distinguishes itself from searching for r.

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

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

The phrase 'Presented period' and 'Does not search for r' make clear this tool is for validating a supplied candidate exponent, not for discovering one. It does not name an explicit alternative tool, but the usage context is sufficiently clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool's exact output (WIN or MISS with the exact rational computed), the input constraints (phase as num/den, m as register width, k as index), and the refusal of floats. It does not mention error handling or side effects, but for a pure verification tool this is sufficient and 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 four sentences, each dense with information: purpose, parameter definitions, example, output format, and behavioral constraints. The core purpose is front-loaded ('certify that the presented phase equals k / 2^m exactly'), followed by parameter explanations and a clear final note on float refusal. No wasted words.

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

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

The tool is moderately complex (mathematical verification), and the description fully covers the required inputs, their relationship, the expected format, the output (WIN or MISS with exact rational), and constraints (floats refused). There is no output schema, so the description appropriately explains the return value. Everything an agent needs to invoke it correctly is present.

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 schema already describes each parameter (k, m, phase) individually, but the description adds substantial meaning by connecting them: it explains the mathematical relationship (k / 2^m), the required format for phase (num/den), and provides a concrete example. This goes well beyond the schema's field-level descriptions, making the parameters' purpose and interplay fully clear.

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

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

The description uses a specific verb ('certify') and a precise resource ('Phase kickback'), then defines the exact mathematical condition (phase equals k / 2^m exactly as a rational). It includes an example (1/2 for m=1, k=1), which removes any ambiguity. The phrase 'No estimation is performed; floats refused' further distinguishes it from approximate verification tools among the 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 clearly states what the tool does and what it does not do ('No estimation is performed; floats refused'), giving implicit guidance on when to use it (exact rational verification) and when not (estimation or float-based checks). However, it does not explicitly name alternative tools or provide a direct 'use this when...' statement, so the guidance is implied rather than explicit.

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

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

With no annotations, the description must disclose behavior. It mentions that it does not invent a third scalar, does not do ECDLP, and returns REFUSED_EMPTY when both faces are empty, but it does not specify the actual return value for win or fail conditions, nor any side effects or error handling. This is a significant gap for a verification 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 description is a dense block of jargon, starting with the cryptic 'QC-021' and using terms like 'FALSE FACE' and 'REFUSED_EMPTY'. It lacks a clean front-loaded summary and is not well-structured. While not overly long, it could be more concise and organized.

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

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

There is no output schema and no annotations, so the description should explain what the tool returns on success, failure, or empty input. It mentions 'WIN' and 'REFUSED_EMPTY' but does not describe the actual output format or behavior in those cases. This is incomplete for an agent to correctly 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%, but the description adds valuable context: it explains that A and k are aliases, Q and q_hex are aliases, and provides format rules (64-hex or decimal, hex can contain 'e', decimal point indicates float). This goes beyond the terse schema descriptions, so it earns a 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 implies that this tool verifies a presented pair of private/public faces, with the win condition being kG==Q. It specifies the roles of A/k and Q/q_hex and states what it does not do (does not ECDLP). However, it lacks explicit differentiation from sibling verify_* tools, so it stops short of a 5.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The description implies usage for verifying a pair but does not state prerequisites, conditions, or alternative tools. The agent must infer the use case.

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 discloses the exact integer return as energy_num/energy_den, the WIN/MISS outcomes, and the constraint 'Floats refused'. It does not mention side effects or auth, but for a read-only verification tool this is adequate. The 'not a search' and 'not a pulse schedule' clarifications further set expectations.

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 dense sentences, front-loaded with purpose. Each sentence serves a function: purpose and exclusions, input format, return semantics and cross-reference. It is slightly cryptic (e.g., 'same law') but efficient and earns its length.

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 2-parameter tool with no output schema, it covers purpose, input format, output (energy_num/energy_den), success/failure indicators (WIN/MISS), and input constraints. It also situates the tool within a domain (qc_qaoa) and law (same as route_spin_glass_manifold). Nothing essential is missing for an agent 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 coverage is 100% (both parameters described), but the description adds concrete examples ('0,1,1;1,2,1;2,0,1'), explains the coupling format (i,j,J integers), and adds the constraint 'Floats refused' – meaningfully enhancing the schema. This goes beyond the baseline of 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?

States a specific verb (certify) and resource (energy of a spin string on an Ising instance), explicitly distinguishing from 'a pulse schedule and not a search', which differentiates it from many verify_* siblings. References the QAOA problem directly, making the tool's intent unmistakable.

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?

Describes the exact scenario (presented spin string on Ising instance) and what it is not (pulse schedule, search). Does not name explicit alternative tools, but the 'same law as route_spin_glass_manifold' hint and the distinct problem scope give clear context. Lacks explicit when-not to use other verify tools, but the purpose 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?

There are no annotations, so the description carries the behavioral disclosure burden. It does disclose meaningful behavior: exact rationals are required, sqrt(n) is not permitted, and floats are refused. However, it says nothing about what the tool returns, how failures are reported, or whether any state changes occur.

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 very brief and each fragment adds information: the resource identifier, the formula, allowed n values, and the float rejection rule. It could include the verb 'verify' early for clarity, but overall it is tightly structured with 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?

For an unannotated verification tool with three undocumented parameters and no output schema, this description is too sparse. It tells the agent what constraints are being checked but not what a successful or failed verification looks like, what the tool returns, or how the inputs should be supplied. Sibling tools and schema provide no compensating detail.

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

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

Schema description coverage is 0%, and the parameter names k, n, and phases are otherwise bare strings. The description partially compensates by defining the phase formula and constraining n to {2,4,8}, plus rejecting floats. It still does not specify formats for the three string parameters or how phases should be encoded.

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 ('QC-003 QFT phase table') and the core invariant being checked, phase[j]=(j*k)/n as exact rationals. This is specific enough to distinguish it from the many sibling verify_* tools, though it never explicitly uses a verb like 'verifies' or 'checks'.

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 acceptance constraints (n in {2,4,8}, no sqrt(n), no floats) but provides no guidance on when to use this tool instead of alternatives such as verify_qpe_phase or verify_phase_kickback. An agent must infer the intended use case.

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

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

With no annotations, the description carries the behavioral burden; it discloses important behaviors: exact equality (no tolerance), m bound, and rejection of floats. It does not say what happens on pass/failure, whether the operation is side-effect-free, or error behavior, leaving part of the behavioral profile implicit.

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 four short, front-loaded statements with no filler. Every fragment adds information: identity, acceptance condition, bound, and input restriction.

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 verifier the core criterion is covered, but with no output schema the description does not state the return/result semantics or behavior on invalid/missing inputs. Also, the schema lists all parameters as optional while the description implies all three are needed, which could confuse an agent.

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

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

Schema coverage is 0%, so the description must define the parameters; it does so via the relation phase = k/2^m and the m<=8 constraint, giving meaning to all three fields. It leaves minor format details (e.g., how strings encode k/m) to inference.

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

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

The description identifies the tool as a QPE verification check and gives the exact acceptance predicate (phase must equal k/2^m exactly), so an agent can tell what is being decided. It does not explicitly name sibling alternatives, but the k/2^m condition and QPE label make this distinct from the other 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?

Usage is implied rather than stated: 'QC-004 QPE' plus the tool name point to QPE phase verification, and constraints like m<=8 and 'Floats refused' guide valid invocations. There is no when-to-use versus alternatives or when-not-to-use 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 provided, the description carries the full burden of behavioral disclosure. It states that the tool verifies a witness (non-destructive), rejects floats, and does not perform amplitude counting. It also specifies the outcome (WIN/MISS). While it doesn't cover edge cases like malformed inputs, the core behavior is transparently described.

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 concise and front-loaded. The first sentence states the purpose, followed by parameter definitions and behavioral notes. Every sentence adds information without redundancy. It is structured logically and easy to parse.

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 verification tool with two parameters and no output schema, the description is complete. It covers input constraints (length, type), the exact verification logic, and the expected result (WIN/MISS). Nothing an agent needs to invoke 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 the baseline is 3. The description adds semantic meaning beyond the schema: it explains that the oracle string's 1s are the marked entries and that count is the claimed number as a decimal string. This helps the agent interpret the parameters correctly, especially the relationship between them.

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

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

The description clearly states the tool's purpose: certifying that a claimed count equals the number of 1s in an oracle string. It uses a specific verb ('certify') and identifies the resource (quantum counting). It also distinguishes itself from sibling verification tools by specifying the exact comparison logic and that it verifies a presented witness rather than performing amplitude counting.

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 implicitly defines when to use the tool: when there is a claimed count and an oracle string to verify. It clarifies that the tool verifies a presented witness and does not perform quantum counting, which helps an agent avoid using it for estimation tasks. However, it does not explicitly name alternative tools or state when not to use it, leaving some inference to the agent.

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

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

With no annotations, the description carries the full burden. It discloses the mathematical logic, input format (decimal strings, 0/1), output (WIN/MISS naming vertex), and a rejection condition ('Floats refused'). It does not cover error handling for invalid inputs, but the core behavior is well explained.

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 purpose. It packs in the rule, input constraints, and output format without fluff, though the 'QC-012' prefix is unexplained but not harmful.

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

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

The tool is simple, and the description covers the verification logic, parameter types, and output. A minor gap is that the schema lists all parameters as optional while the tool likely requires them for verification, and this is not clarified. Still, an agent can infer the necessary inputs.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds relational meaning by explaining how steps, start, and end interact via the even/odd rule, going beyond the individual field descriptions.

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

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

The description states a specific verb ('certify') and resource ('quantum walk on the two-vertex cycle C2'), with an explicit rule for even/odd steps. It clearly distinguishes from sibling verify_* tools by naming the exact algorithm and cycle type.

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

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

Provides clear context: this verifies a quantum walk on C2. It does not explicitly mention alternatives or when not to use it, but the algorithm-specific nature makes the intended use obvious among sibling tools.

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

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

With no annotations, the description carries the full disclosure burden, and it delivers: it states input restrictions ('Floats refused'), scopes the verification mathematically, explains what it does not do, and discloses the return topology for Q exposes including period_r semantics and where companion images travel. This goes well beyond a basic statement of effect and gives an agent real behavioral insight.

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

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

The description is information-dense and front-loaded with the key certifier purpose, and every sentence contributes technical meaning. However, it is written as a terse spirals of specialized tokens ('patusi_expose', 'shors_qmt_witness', 'topological_shear', 'jordan_proven') that are not defined, and 'QC-001' adds no functional value. It is compact but not optimally easy for an agent to parse.

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 Q expose path is described in detail, with return pieces, companion-image transport, and verdict semantics, but the standard non-Q return value is not described at all. The schema lists Required as empty while the description implies N, halfPow, factor, and cofactor are the presented core values, leaving ambiguity about which parameters are mandatory. For a verifier with no output schema and no annotations, this is a meaningful completeness 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 only 33%, but the description compensates for the undocumented N, halfPow, factor, and cofactor by defining them as decimal strings and giving their exact verification conditions. It also clarifies q_hex/object as an optional Q-only Affine expose with no k. The main weakness is that the meaning of 'halfPow' and the precise role of q_hex are left somewhat implicit, but this is still strong compensation for the schema gap.

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

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

The description identifies a specific verb/resource: it certifies a Shor witness for (N, halfPow, factor, cofactor) and states the exact mathematical conditions that must hold. It also draws a useful boundary by explicitly saying 'Does not find a period,' which helps distinguish it from verify_period. The heavy internal jargon and oblique Q expose wording keep it from being fully crisp, so it stops short of 5.

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

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

The intended input context is clear: call this when you have N, halfPow, factor, cofactor as decimal strings, and optionally a q_hex/object for a Q-only expose. The statement 'Does not find a period' is an explicit negative usage signal, though it does not name verify_period directly. There is no thorough when-not-to-use guidance for the other sibling verifiers, so it earns a 4 rather than 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 provided, the description carries the full burden of disclosing behavior. It states the verification logic, the refusal of floats, and that the mask is presented rather than recovered. This is substantial transparency for a verification tool. It does not cover all possible error states or side effects, but the description is honest about what the tool does and does not do.

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 with no fluff. It front-loads the purpose and immediately states the verification conditions. Every clause adds value: the collision conditions, the WIN/MISS outcome, and the constraints on mask and floats. It is concise without sacrificing necessary detail.

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

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

Given the five parameters and no output schema, the description covers the essential logic and constraints. It explains the verification conditions and the result format (WIN/MISS). It does not describe edge cases like empty strings or how the mask is presented, but these are minor given the clarity of the tool's purpose. The description is sufficient for an agent to invoke it correctly in most scenarios.

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%, but the description adds critical relational semantics beyond the individual parameter descriptions. It explicitly states that x XOR y must equal mask, that fx and fy must be equal, and that fx can be decimal or bit string. This tells an agent how parameters interrelate, which is not evident from the schema alone.

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

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

The description uses a specific verb 'certify' with a clear resource (presented collision for Simon's algorithm) and defines the exact conditions (x != y, x XOR y == mask, f(x) == f(y)). It distinguishes itself from the many sibling verify_* tools by naming the algorithm (Simon) and the specific relation being checked, making its purpose unambiguous.

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

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

The description specifies when the tool wins (WIN when all three hold) and when it misses (MISS naming the failing relation), which effectively tells an agent the criteria for correct invocation. It also notes constraints ('Floats refused', 'mask is presented, never recovered') that affect usage. However, it does not explicitly contrast with alternative verify tools, though the specialization makes the intended use clear.

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

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

Since no annotations are provided, the description carries the behavioral disclosure burden. It does add useful behavioral traits: the decoded two bits must match the sent two bits, and float inputs are refused. However, it is silent on return format, behavior on mismatch, and validation beyond floats, so transparency 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 very short and front-loads the key criterion; each clause earns its place. The 'QC-017' prefix is mildly extraneous, and the fragment style is terse, but there is no filler or redundancy.

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

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

For a tool with no annotations, no output schema, and a bare input schema, this is incomplete. An agent still does not know what response to expect, whether a mismatch returns false or raises an error, or whether both parameters are mandatory, and the description does not distinguish it from the many sibling verify_* tools beyond its protocol identifier.

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

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

With 0% schema coverage, the description must explain the parameters. It maps 'sent 2 bits' to the bits parameter and 'decoded' to decoded, and implies both are 2-bit strings. It does not explicitly name the parameters, define the allowed bit-string format, or state that both are required, so it only partially compensates for the bare 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 identifies the resource (superdense coding) and the verification criterion (decoded 2 bits must equal sent 2 bits), so a caller can tell it apart from other verify_* sibling tools. It is not a full sentence with an explicit 'verifies/checks' verb, and 'QC-017' adds no operational meaning, but the intent is unambiguous from name plus criterion.

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 given about when to choose this tool instead of sibling verifiers such as verify_teleport or verify_bell_measurement. The protocol name implies the use case (superdense coding), but there is no explicit condition, prerequisite, or alternative 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 must carry behavioral disclosure. It does explain the core check ('bob = alice XOR corrections') and an input constraint ('Floats refused'), which is meaningful. However, it does not say whether the tool has side effects, what it returns, or how it reports success/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?

The description is extremely compact and front-loaded, with each sentence contributing distinct information: protocol context, the verification relation, and an input restriction. There is no filler or redundancy.

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

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

The tool has three parameters and no output schema, yet the description does not explain the return value, expected bitstring format, or error behavior. It also lacks usage context beyond the formula. The core equation is present, but an agent would likely need additional information to call it reliably.

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

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

Schema description coverage is 0%, so the description must provide parameter meaning. The formula 'bob = alice XOR corrections' assigns roles to all three parameters and clarifies their relationship, and 'on 2 bits' adds a size constraint. It does not fully specify the expected string encoding, but it compensates substantially for the empty schema descriptions.

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

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

The description names the specific resource ('QC-016 Teleport reconstruction') and gives the verification criterion ('bob = alice XOR corrections on 2 bits'), which clearly identifies the tool as a teleport verification tool. It distinguishes itself from the many sibling verify_* tools by focusing on teleportation, though the 'QC-016' code is somewhat opaque and the verb 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 tool versus alternatives such as verify_bell_measurement or verify_superdense. The description simply gives the operation and restriction, leaving the agent to infer usage from the name and formula. No exclusions or alternative conditions are provided.

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

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

With no annotations, the description carries behavioral disclosure itself. It states the success condition ('WIN when (q, r) equals the sealed pair'), the failure condition ('MISS naming it'), and an input rejection rule ('Floats refused'). This gives meaningful behavioral expectations beyond the schema.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds distinct useful information: allowed words, success/failure conditions, and float rejection. There is no filler or repetition of schema fields.

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

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

For a simple 3-parameter verification tool with no output schema, the description provides the purpose, allowed values, input constraints, and outcome semantics. It does not explicitly state that all three parameters are needed, but the prose strongly implies it and the schema leaves required empty.

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 value by clarifying that q and r are claimed integers, that they must match a sealed pair, and that floats are refused. This goes beyond the schema's simple 'claimed Eisenstein q, decimal' notes.

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?

Description begins with a specific verb and resource: 'certify that the presented Eisenstein pair (q, r) is the sealed pair for a cited word.' It names exactly the two allowed words and explicitly distinguishes this from 'a group scan,' which separates it from sibling 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?

The description gives clear context for when this tool applies: it is for certifying sealed corpus words Z2_a2b or Z2_abAB, and explicitly says it is 'not a group scan.' It does not name an alternative verbatim, but the scope and exclusion are enough to route an agent appropriately.

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 behavioral burden. It does disclose meaningful constraints: this is a VQE-energy verification task rather than a search, it follows the same ZZ law as execute_2local_hamiltonian, and floats are refused. But it does not say what 'verify' returns, whether it mutates state, or what 'refused' means at the API level, so the behavioral picture is 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?

The description is short and front-loaded, with no filler, but it is fragmented and telegraphic: 'Presented config energy' and 'Floats refused' are not complete sentences and may confuse more than help. The terse style saves space but sacrifices enough grammatical clarity that it cannot earn a higher score.

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 annotations, no output schema, two undocumented parameters, and no required fields, this description is too thin. An agent cannot reliably know what config and constraints should contain, what a successful verification looks like, or how the relationship to execute_2local_hamiltonian should inform the call. The description gives useful hints but is not self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate, but it only vaguely alludes to 'config energy' and says 'Floats refused'. The constraints parameter is never explained, no format is given for either string, and there is no guidance on how config and constraints relate. This is a real gap for an agent trying to construct valid arguments.

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 tool as a QC-013 VQE problem verifier and explicitly distinguishes it from 'the variational search', so an agent can tell what scope it covers. It also references the same ZZ law as execute_2local_hamiltonian, which further anchors its purpose, though it never spells out a full verb phrase like 'verifies whether the presented config energy is correct'.

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

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

The phrase 'not the variational search' gives one clear when-not signal, and the reference to execute_2local_hamiltonian gives a related tool comparison. However, there is no explicit guidance on when to choose this tool over sibling verifiers such as verify_qaoa_energy or verify_presented_pair, and no stated prerequisite or invocation context.

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

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

With no annotations, the description carries the full disclosure burden and meets it: it reveals exact integer crossing arithmetic, no floating point/epsilon, squared-distance standoff, non-convex support, altitude-layer scoping, and breach naming behavior. This goes well beyond the schema.

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

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

Three dense sentences all earn their place: the core operation, the exactness guarantees, and the advisory scope. The critical behavior is front-loaded in the first sentence, and there is no filler or repetition.

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

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

For a complex geometric tool with no output schema, the description is unusually complete: it specifies inputs, exact method, edge semantics (altitude layer, non-convex footprints), breach reporting, and authority limitations. Nothing needed to correctly choose and invoke it 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 complete, so the description only needs to add meaning, and it does: margin_micro_deg is clarified as a strict squared-distance comparator with no square root, and track_micro_deg is framed as a segment sequence for breach naming. It does not exhaustively re-map every cell field, but the schema already covers them.

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

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

The description uses a specific verb plus resource: it decides containment of a track against convective cell boundaries and names what a breach must report. The 'Advisory only; not a dispatch or flight-planning authority' sentence separates it from atc/planning siblings, so purpose is unambiguous.

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

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

It clearly states the operation's scope and an explicit non-use ('Advisory only; not a dispatch or flight-planning authority'). However, it never names an alternative tool or the condition under which a sibling such as atc.assert_4d_deconfliction should be used instead.

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