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

No annotations exist, so the description carries the full burden. 'Allow' implies a mutating permission grant, but the description doesn't say what is changed, whether it is reversible, what approval flow the approved_by field triggers, or what happens if an existing quote conflicts. It does hint that a functional-necessity justification is required, which is modest value.

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

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

It is a single front-loaded sentence with the mode restriction first, so it is compact. However, the terseness comes at the cost of intelligibility: 'literal' and 'gate' are undefined jargon rather than efficient shorthand.

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

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

This is a likely mutation tool with three required parameters, zero schema coverage, and no annotations; the output schema covers return values but nothing else. The description omits prerequisites, approver semantics, mode definitions, and the effect of the operation, so it is not sufficient to call the tool correctly.

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

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

Schema description coverage is 0% and all three parameters are required with bare titles. The description roughly maps to compat_reason ('the reason it is functionally necessary') and maybe 'text' ('one literal'), but approved_by is completely unaddressed, so it fails to compensate for the coverage gap.

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

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

The description says 'allow one literal through the gate,' which is metaphor rather than a concrete verb+resource. An agent cannot tell what artifact is modified (a rule? a spec? a compatibility exception?) or what the effect on the system is, so the purpose is only vaguely inferable from the name and sibling set.

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?

'Standard mode only' implies a conditional context, but it never defines what standard mode is or what the alternative is. No sibling is named, and with tools like propose_claim, compile_spec, and check_rules present, an agent gets no signal for choosing add_quote over them.

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

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

No annotations exist, so the description carries the full burden. It hints that the answer is 'gate-checked', which is genuinely behavioral context, but does not say whether a failed gate rejects the answer, raises an error, mutates ticket state, or what permissions are required. The single behavioral hint is left undefined.

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 front-loaded sentence with no wasted words, but its brevity comes at the cost of clarity – the jargon-dense phrasing is under-specified rather than crisp. Compact but cryptic.

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 output schema covers return values, but with no annotations and zero parameter descriptions, the description needed to explain the 'clean-side' concept, gate semantics, and error behavior. Given the specialized domain vocabulary in the sibling tool set, it leaves the agent unable to call this confidently.

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

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

Schema description coverage is 0% for both required parameters. The description does not say what format ticket_id takes, whether the answer is free text or structured, length limits, or how 'gate-checked' constrains the answer content. The only hint is that an 'answer' exists and is validated.

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

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

The verb 'answer' and resource 'question/ticket' are present, so the basic action is identifiable. However, the two defining terms 'clean-side' and 'gate-checked' are unexplained domain jargon, and nothing distinguishes this from sibling tools like list_tickets or check_rules. Purpose is implied rather than stated.

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

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

There is no guidance on when to invoke this versus alternatives (e.g., list_tickets to obtain a ticket_id, or check_rules to see gate criteria). No prerequisites, ordering constraints, or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden. It does disclose that the contract is value-free and reflects what has been observed so far, which is useful behavioral context, but it does not state read-only behavior, freshness, coverage limits, or what happens if no contract has been observed.

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 with no filler. The core resource description is front-loaded and the folding instruction follows immediately.

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

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

An output schema exists, so return values need not be explained, and zero parameters keep the schema burden low. However, the description remains thin on when to use this tool versus the many sibling tools and does not clarify how the observed contract relates to compile_spec or review_spec workflows.

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 baseline is 4. The description does not need to explain parameter semantics, though it references target_options.api_templates as external configuration context.

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

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

The description identifies a specific resource — the observed backend API contract — and enumerates contents: paths, methods, statuses, body shapes. It is clearer than the bare name, though it lacks an explicit verb and does not distinguish itself from siblings such as compile_spec or review_spec.

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

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

It gives an instruction about folding data-bearing path segments using target_options.api_templates, but does not say when to call api_contract instead of alternatives, nor does it state prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It says approval is recorded and restricted to standard mode, but it does not describe side effects, permissions, reversibility, conflicts, or what happens when action_ids is omitted.

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 tight sentences with the mode restriction and main action front-loaded. Every sentence contributes directly to explaining the approval behavior.

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

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

An output schema exists, so return values need not be explained. But with no annotations, three parameters, and 0% schema description coverage, the description is too sparse about parameter meaning, approval side effects, and alternative tools.

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

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

Schema description coverage is 0%, and all three parameters lack schema descriptions. The description loosely implies 'who approved it' maps to approved_by, but it does not explain feature or action_ids, leaving most parameter meaning undocumented.

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

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

The description uses a specific verb, 'approve', and identifies the resource as byte-exact observed output required by behavior. It also scopes the tool to standard mode and mentions default help/usage/version output, but it does not explicitly distinguish this approval action from related siblings such as add_quote or propose_claim.

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 'Standard mode only' gives a usage condition, and the parenthetical default identifies common applicable output types. However, the description does not name alternatives or explain when not to use this tool compared with related quote/claim/spec tools.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It does not explain what a failed verification looks like, whether it mutates state, whether special authorization is required, or how the hash chain is traversed.

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, front-loaded sentence with no filler. Every word contributes to the stated purpose.

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

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

For a zero-parameter verification tool with an output schema, the description is nearly complete: it identifies the object and action. The remaining gap is behavioral context around failure and security implications, which is not covered by annotations.

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

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

The tool has zero parameters and a fully described empty schema, so there are no parameter semantics to explain. A baseline of 4 is appropriate because the description is not expected to add parameter detail for a no-argument tool.

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

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

The description states a specific verb and resource: verify the audit log's hash chain. It is clear what the tool does, though it does not differentiate itself from any sibling because no sibling appears to overlap directly.

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

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

There is no guidance on when to use this tool, when not to use it, or what preconditions must hold before verification. The agent must infer that this is a read-only integrity check from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses the temporal scope of one episode (reset + actions) and implies an observational read, but it does not explicitly state side effects, permissions, or whether the operation is read-only.

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 core resource and includes the key usage condition. It is efficient, though the semicolon-heavy structure could be slightly easier to parse if split.

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

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

An output schema exists, so return values need not be described. However, with no annotations and zero schema description coverage, the description leaves the actions parameter unexplained and does not fully address behavioral traits such as read-only status.

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 sole optional parameter, actions, is not explained. The description mentions 'actions' only as part of the episode context, not as a parameter with type, format, or default behavior.

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 resource as third-party hosts the app tried to load during a web episode, which is more specific than the bare tool name. It does not explicitly distinguish this from sibling web-probing tools, so it earns a 4 rather than 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?

It gives a clear usage condition: these hosts are candidates for target_options.profile.asset_hosts when layout depends on them. It does not mention when not to use the tool or name alternative sibling tools, 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?

Without annotations, the description must carry the full burden of behavioral disclosure. It mentions that falsified documented rules are reported as documentation/behavior conflicts, which is a useful behavioral trait, but it omits critical details like whether the tool mutates state, what permissions are required, or how it handles non-documented rules.

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

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

The description is front-loaded with the purpose and then efficiently describes the rule format. It uses compact notation and avoids unnecessary words, though the dense structure may be slightly cryptic for quick parsing.

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

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

With no annotations, an output schema, and complex rules parameter, the description is partially complete. It thoroughly covers the rules parameter but fails to explain the 'feature' parameter or clarify what 'original' refers to, which are critical for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It provides a detailed explanation of the 'rules' parameter, including the structure and allowed values for each rule, which adds significant meaning beyond the schema. However, it completely ignores the required 'feature' parameter, leaving a substantial 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 begins with 'Check observer-authored rules against the original,' which states a verb and resource, but 'original' is undefined and the tool is not clearly distinguished from siblings like falsify_claim or list_rules. The subsequent rule format details add specificity but don't fully clarify the tool's core purpose relative to its ecosystem.

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 falsify_claim or list_rules. The description only explains the rule structure, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full behavioral burden and says nothing about side effects — whether a compile writes or overwrites a draft, is idempotent, or requires prior claims/unknowns to exist. Only the existence of an output schema saves the agent from total blindness about results.

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

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

One short sentence, front-loaded with the verb and the output artifact. No filler. The brevity is only a problem because nothing else compensates, not because the sentence is padded.

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

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

For a tool with zero annotation coverage and no parameter documentation, the description should explain the lifecycle position and side effects. The output schema covers return values, but nothing tells the agent what must exist beforehand or what this changes.

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

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

Schema description coverage is 0% for the single 'feature' parameter. The phrase 'for a feature' weakly signals that the argument is a feature identifier, but gives no format, expected naming, or whether it must match an existing feature record.

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

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

The verb 'compile' and resource 'spec draft' are named, and the parenthetical 'model + claims + unknowns' hints at what gets produced. But 'compile' is jargon — it's unclear whether this assembles, validates, or generates — and there's no explicit contrast with siblings like review_spec or release_spec that sit in the same lifecycle.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent can infer from sibling names that a propose → compile → review → release pipeline may exist, but the description itself offers nothing to route on.

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 the behavioral burden. It usefully discloses a side effect (uncovered items become unknowns) and that options are added automatically, but it omits permissions, idempotency, whether existing unknowns are updated vs created, and other mutation semantics.

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

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

Two short sentences keep it front-loaded and efficient. The parenthetical 'options are added automatically' is somewhat cryptic but not verbose.

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

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

An output schema reduces the need to describe return values, but for a tool with a mutation side effect and no annotations, the description is still incomplete: the 'feature' parameter is undefined, null inventory behavior is unexplained, and the side effect is only partially described.

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 should explain both parameters. It clarifies the inventory shape as {item: [patterns]}, but never defines the required 'feature' parameter or explains what a null inventory means.

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

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

The description conveys that this tool computes coverage of a feature inventory using probes and rule checks, and that uncovered items become unknowns. However, it is phrased as a noun phrase rather than a clear verb+resource, and it overlaps conceptually with siblings like check_rules and list_feature_unknowns without explicitly differentiating itself.

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

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

It offers no explicit when-to-use or when-not-to-use guidance and does not name alternatives. The note that uncovered items become unknowns describes an outcome, not a selection criterion.

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 of behavioral disclosure. It lists the fields of an action but does not state whether defining actions persists them, whether existing actions are overwritten, what permissions are needed, or how errors are handled. This is a significant gap for a mutation-style definition 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 single tightly written sentence that front-loads the core purpose and follows with the relevant field list. 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?

An output schema exists, so return values need not be explained. However, the tool accepts a complex nested object with arbitrary properties and no annotations, and the description does not clarify the mapping structure, required sub-fields, or the semantics of fields such as stdin_mode and stdout_mode. It is minimally adequate but leaves important details to inference.

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

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

Schema description coverage is 0%, so the description must compensate. It enumerates the per-action fields (argv, stdin, files, env, stdin_mode, stdout_mode, timeout_s), which is meaningful semantic information absent from the schema. It still does not explain value formats or required sub-fields, but it substantially improves understanding of the nested parameter.

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 and resource: "Define named actions" for "learning flows of stateful CLIs." It does not explicitly distinguish itself from sibling tools like learn_flow or run_sequence, but the stated purpose is clear enough for an agent to understand what the tool does.

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 the context ("for learning flows of stateful CLIs") but offers no explicit guidance on when to use this tool versus alternatives like run_sequence, learn_flow, or discover_cli. There are no exclusions, prerequisites, or alternative-routing instructions.

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 does add real behavioral context: help prose is downgraded to 'dirty-side evidence' and only confirmed structure is returned, so the agent knows not to trust raw help text. It omits important traits for a tool that must execute a CLI to probe it — whether the command is actually run, side effects, safety, or any permission/auth requirements.

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 with the purpose front-loaded and no padding. 'Dirty-side evidence' is slightly jargon-y but earns its place by signaling the trust level of help output.

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

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

An output schema exists, so return structure need not be spelled out, and the description correctly frames the result. But for a tool that executes an external binary, missing execution semantics and an unexplained second parameter leave meaningful gaps.

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

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

Schema coverage is 0%, so the description must carry the parameter burden and does not. 'cmd' is self-evident, but 'takes_files' (boolean, default true) is never explained — the agent cannot tell whether it declares that the target CLI accepts file arguments or whether the tool itself should pass files.

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

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

States a specific verb and resource ('Discover a CLI's interface') and even describes the shape of the result (options, arity, value types), which is more than most definitions offer. It does not, however, distinguish itself from sibling probe_cli or discover_ui, leaving the agent to infer which discovery tool to pick.

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

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

Usage is only implied: the phrase 'help structure confirmed by behavior probes' hints that this is a discovery step feeding later probing, but there is no explicit when-to-use, when-not-to-use, or named alternative among siblings like probe_cli or discover_ui.

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 load and does add real context: it discloses that it clicks every enabled control, how screens are identified, and that it persists an inventory consumed by later tools. However it omits material behavior for a stateful crawler — that clicking live controls can mutate application state, that a target session must already exist, and that runs are bounded by state/depth caps.

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 dense sentences with the purpose front-loaded and the sequencing instruction at the end; every clause carries information. The middle sentence runs long with several comma-separated behaviors, which slightly hurts scannability.

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

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

The output schema removes the need to describe return values, and the crawl concept is conveyed. But for a five-parameter, potentially state-mutating crawl with zero annotation coverage, leaving four parameters and the session/prerequisite situation unexplained leaves the definition only partially complete.

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

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

Schema description coverage is 0% across five parameters, so the schema offers no help, and the description only explains `start` (named actions such as a sign-in). The meaning and effect of `fill`, `feature`, `max_depth` and `max_states` — especially the crawl bounds — are left entirely 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?

States a specific verb and resource — crawl the UI from the start screen, clicking every enabled control — and defines what it produces (a click[role:name] action per control plus an inventory). This clearly separates it from discover_cli and probe_web_field, and it names the downstream consumers (coverage, suggest_probes).

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?

"Start here, then probe fields and state rules" gives explicit ordering relative to the probe tools and establishes the entry-point role. It stops short of naming exclusions (e.g. when to choose discover_cli or open_target first), so not a full when/when-not treatment.

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. It does reveal that probes are fresh and uncached (likely meaning repeated live execution against the target, with cost and non-determinism), but it never states side effects, whether the claim's state changes, what happens on inconclusive results, or any rate/permission constraints for a tool that appears to run live probes.

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

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

One tight sentence with no filler and the core action front-loaded. It is efficient, though the terseness is part of why key semantics are missing rather than a model of well-structured brevity.

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

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

Placeholder — see justification correction below.

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 and does not. Neither claim_id nor repeats is explained; in particular the meaning of repeats (default 3) — how many probe attempts per falsification run, and whether they must all fail to falsify — is left entirely opaque.

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

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

States a specific verb and resource ('falsify a claim') and adds a mechanism note ('fresh, uncached probes'), which distinguishes it from propose_claim and list_claims. However, it does not explicitly contrast with adjacent tools like suggest_probes or check_rules, so differentiation is only partial.

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

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

There is no statement of when to prefer this over suggest_probes, check_rules, or audit_verify, and no preconditions (e.g. the claim must exist and be in a falsifiable state). The only usage signal is the implied 'use this to test a claim', which an agent must infer.

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

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

With no annotations, the description carries the full burden. It usefully discloses the key side effect: paragraphs join the gate corpus and copied wording is flagged. It leaves out operational details such as whether ingestion is idempotent, what qualifies as public, and whether entries can be removed.

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 definition is a single compact sentence with no wasted language. The core action and intended effect 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?

The presence of an output schema reduces the need to explain return values. Still, for an ingestion/mutation tool with no annotations and undocumented parameters, the description is only minimally complete: it explains the corpus effect but not enough about accepted inputs or operational 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 0%, so the description must explain the two required parameters. It only gives vague context: source and text are not defined, and it does not say whether source is a URL, citation, or label, nor what text should contain.

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

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

The description gives a specific verb-resource pair: registering public documentation and adding its paragraphs to the gate corpus. It clearly explains the copy-detection purpose, though it does not explicitly differentiate this tool from nearby claim, quote, or rule 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 implies the right usage context: register documentation you have read so copied wording is flagged, and write rules in your own words. However, it gives no explicit when-not-to-use guidance, prerequisites, or named alternative tools.

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

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

No annotations are provided, so the description carries the full behavioral burden and falls well short: it doesn't say whether this mutates the rule/claim store, how long a learn run takes, what 'oracle budget' means operationally, or what happens when the budget is exhausted. The one hint of cost-awareness is not actionable.

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

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

It is a single front-loaded sentence with no padding, which is structurally sound. However, the space that is used is spent on unexplained abbreviations and a budget concept that maps to no input, so brevity comes at the cost of usefulness rather than from efficiency.

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

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

An output schema exists, so return values needn't be described, but for a 5-parameter, no-annotation, presumably long-running learning operation the description leaves out mutation side effects, budget semantics, algorithm choices, and parameter meanings. It is not complete enough for an agent to invoke this correctly on the first attempt.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and does not: 'feature' is only implicitly referenced, 'KV or L#' loosely maps to the 'algorithm' parameter without naming it or listing valid values, and 'alphabet', 'walk_len', and 'walks_per_state' are entirely unaddressed — including the required 'alphabet' array.

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

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

The verb+resource ('learn a state machine for a feature') is identifiable, but the qualifiers 'KV or L#' and 'explicit oracle budget' are unexplained jargon and the budget concept has no corresponding parameter. An agent can guess the general purpose but cannot confidently predict what the tool will do with its inputs.

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

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

There is no statement of when to use this versus the many sibling tools (check_rules, coverage, discover_ui, suggest_probes, etc.), nor any prerequisite or follow-up guidance. The phrase 'under an explicit oracle budget' hints at a cost constraint but never says when that constraint applies or how to satisfy 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 the full burden. "List" implies a read, but it says nothing about volume, pagination, ordering, or what happens when the supplied feature does not exist (empty result vs error). For an unannotated tool this is a substantial disclosure 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?

One short sentence, front-loaded with the verb and resource, with zero filler. Brevity is appropriate, though it is terse to the point of omitting behavior rather than being padded.

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

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

An output schema exists so return shape needn't be described, but with no annotations, an undocumented filter parameter, and no statement of scoping or failure behavior, the definition is too thin for an agent to call it confidently.

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

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

With a single parameter at 0% schema description coverage, the description must compensate; it does state that feature is optional and acts as a filter, which is the main semantic. It stops short of saying whether the value is a feature name/ID or how unknown or non-matching features are handled.

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

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

The verb+resource pair ("List claims") is specific, and the optional feature scope is stated, but the domain term "claim" is never explained and nothing distinguishes this from siblings like list_rules or list_feature_unknowns. An agent can guess it enumerates claim objects but not what a claim is in this system.

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?

"optionally for one feature" hints at a filtering use case but gives no when-to-use/when-not guidance and never names an alternative (e.g., when to inspect claims via list_rules or a spec tool instead). The agent must infer selection criteria entirely.

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

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

With no annotations, the description must carry behavioral disclosure itself. "List" implies a read and the mention of returned fields (id, question, status) and the two provenance sources add useful context, but nothing is said about the optional feature filter's scoping effect, ordering, volume, or permissions required.

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

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

A single front-loaded sentence with no filler; the verb and scope lead. The parenthetical about provenance is slightly dense but earns its place by clarifying that coverage-generated entries are included.

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

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

An output schema exists, so field-level return detail is redundant (though harmless), and the follow-up action is covered. The gap is the undocumented `feature` parameter combined with zero annotations, meaning the description says nothing about filtering behavior or result scope.

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

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

Schema description coverage is 0% for the single `feature` parameter, and the description never mentions it. This leaves an unlabeled optional filter whose semantics — whether it narrows results to one feature or defaults to all — must be guessed from the parameter name 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?

States a specific verb and resource ("List unknowns") and scopes it ("yours and the ones coverage generated"), which separates it from record_unknown and update_unknown siblings. It does not explicitly contrast with list_claims or list_rules, but the resource noun is distinct enough that selection 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 a clear workflow cue: these unknowns exist "so they can be answered with update_unknown," routing the agent to the correct follow-up tool. It does not state when not to use this tool or what the list omits, so it falls short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the burden. 'List' implies a read-only operation and it discloses the returned fields (id, statement, status, failed checks), which is useful, but it says nothing about authorization, pagination, or whether the read is recursive.

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

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

A single tight sentence, front-loaded with the verb and resource, with the returned fields appended. Every clause is informative.

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

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

An output schema exists so return-value detail is largely covered, and the tool is a simple one-parameter read. However, with no annotations the description should do more to establish the read-only nature and the meaning/format of the feature argument.

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

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

Schema coverage is 0% and the single 'feature' parameter has no schema description. The description clarifies that 'feature' scopes the query, which compensates somewhat, but gives no format or example for the identifier.

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

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

States a specific verb (List) and resource (rules) scoped to a feature, and names the returned fields. It does not differentiate from siblings like list_claims or the related check_rules/retract_rule, which prevents a top score.

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

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

There is no explicit when-to-use or when-not guidance, and no mention of alternatives such as check_rules (which presumably validates rules) or retract_rule. Usage is only implied by 'recorded for a feature'.

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 delivers almost nothing: no pagination, ordering, filtering, or scope boundaries are stated. The phrase "clean side" gestures at a scoping concept but never defines it, so it adds ambiguity rather than 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?

It is a single short sentence with no filler, so length is not the problem. However, the brevity comes from under-specification rather than economy — the one clause present is the opaque "clean side" phrase, which does not front-load actionable information.

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

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

An output schema exists, so return values need not be described. Still, for a listing tool in a suite with list_claims, list_rules, and answer_ticket siblings, the agent needs to know what set is returned, how it is ordered, and how it relates to answering — none of which is present, and "clean side" is never defined.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. Nothing in the schema is left unexplained by the description.

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?

"List questions" restates the name (tickets ≈ questions) without distinguishing it from siblings like list_claims or list_rules, and the qualifier "from the clean side" is unexplained jargon rather than a scope definition. An agent cannot tell what a "clean side" is or whether it wants these results.

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

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

There is no when-to-use guidance, no mention of the apparently related answer_ticket sibling, and no stated preconditions. The only implied usage is that listed items can presumably be answered, which the agent must infer from the sibling list rather than the description.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that intake records purpose, jurisdiction, and ToS, and that strict mode requires human approval at a terminal, but it omits what side effects occur, whether state persists, and how failures are surfaced for a stateful open operation.

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

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

The description is front-loaded with the main action in the first sentence, followed by target formats and then strict/option details. It is dense but each sentence carries operational information; minor ellipses in the target_options profile list reduce clarity slightly.

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

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

An output schema exists, so return values need not be explained. However, for a 10-parameter, annotation-free tool with 0% schema coverage, the description leaves several parameters and nested target_options details undefined, relying on an external observer guide.

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

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

Schema description coverage is 0% across 10 parameters, so the description must compensate and only partially does. It documents target formats, strict, and some target_options keys, but purpose, jurisdiction, terms_text, owner_declaration, account, real_names, and especially max_actions_per_second receive little or no 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 states a clear verb and resource: 'Open a target and record intake (declared purpose, jurisdiction, ToS snapshot).' The enumerated target forms (cli:docker, web:, android:, desktop:) make the operation concrete. It does not explicitly contrast with siblings like discover_ui or probe_cli, but the scope is distinct enough.

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 as the first step before other target-scoped tools, but the description never states when to use this versus alternatives such as discover_ui, probe_cli, or learn_flow. There are no explicit exclusions or prerequisites beyond the strict-mode note.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the internal process (sweeps, pairwise combinations, noise calibration via rerun and env variations), but it does not state whether CLI commands are executed, what side effects or permissions are involved, or any safety constraints. The output schema covers return values, so that gap is less serious.

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

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

The description is front-loaded with the tool's purpose and then enumerates key processes. It is dense but not wasteful, and the hints key list, while long, is necessary to partially compensate for the schema's lack of descriptions.

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

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

This is a complex probing tool with a nested hints object and no annotations. While an output schema exists, the description leaves too much unspecified about parameter semantics, execution behavior, and safety for an agent to invoke it confidently without inspecting the implementation.

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

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

Schema description coverage is 0%, and there are four parameters including a nested hints object with many keys. The description lists the hints keys, which is helpful, but provides no meaning, type, constraints, or examples for any of them, and top-level parameters like feature, pairwise, and env_sample are only obliquely referenced.

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

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

The description states a specific verb and resource: probing a CLI feature. It enumerates the probing modes (one-factor sweep, pairwise, noise calibration, probe table, mined claims/unknowns), so the purpose is clear, but it does not explicitly distinguish this tool from siblings like discover_cli or suggest_probes.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as suggest_probes, discover_cli, or probe_web_field. The only usage signal is the implied context of probing a CLI feature, with no stated prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose meaningful mechanics: boundary classes become named actions, submit controls whether an action is invoked, and number fields skip length probing. It does not disclose whether submitted forms can mutate state, what permissions are required, or any safety/rate-limit considerations, which is a notable omission for a UI-probing tool that may submit forms.

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 operation, but it is dense with domain jargon such as 'folded claims' and 'learn_flow's alphabet,' making it harder to parse. The content is not bloated, but the structure could be clearer for an agent unfamiliar with the project vocabulary.

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

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

This is a complex 10-parameter tool with no annotations and no schema descriptions, so the description needs to be more complete. It covers several key parameters and behaviors, but required parameters and safety implications of submitting forms remain unexplained; the output schema does at least cover return values.

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

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

Schema description coverage is 0% across 10 parameters, so the description must compensate. It explains `prefix`, `submit`, `classes`, `kind`, and `accepted_if`, but leaves required parameters like `feature`, `role`, and `name` plus `valid` and `boundary` unexplained, forcing the agent to guess their 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 description gives a specific verb and resource: 'Probe one form field (web, Android or desktop UI)' and states the core outputs (equivalence classes, boundary search, per-class outcomes). It is clear what the tool does, though it does not explicitly differentiate itself from siblings such as probe_cli or discover_ui.

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 useful operational conditionals: number fields skip the length search, and without a `submit` action the outcome is read right after typing. However, it never states when to choose this tool over alternatives like probe_cli or discover_ui, so usage is implied rather than explicitly guided.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether proposing persists a claim, whether it is validated against rules, or what happens afterward (though an output schema exists, the mutation/profile behavior is unstated). The only behavioral hint is the 'null = any' note on 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?

It is a single front-loaded sentence with no waste, but for a complex 8-parameter tool it is too terse, pushing semantics into a dense parenthetical rather than structuring useful guidance.

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 8 parameters, 0% schema description coverage, and no annotations, the definition is far from complete. An output schema reduces the need to explain returns, but the input semantics and behavioral profile are largely missing for a tool this complex.

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

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

Schema description coverage is 0% across 8 parameters (5 required), and the description explains only 'expect' (symbol per step, null = any). It says nothing about kind, feature, statement, inputs, layer, origin, or strictness, leaving the majority of parameters undocumented.

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

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

The description names a verb ('State') and a resource ('a falsifiable claim'), plus a parenthetical about 'expect'. However, it does not clarify what a 'claim' or 'trace check' actually is, and offers no differentiation from the sibling falsify_claim (the natural counterpart to a propose). An agent can guess the general idea but not the precise 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 indication of when to use this versus falsify_claim or list_claims, no prerequisites, and no exclusions. The agent is left to infer the workflow entirely.

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

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

No annotations are provided, so the description must carry the behavioral burden. It explains the key domain rule that missing coverage is unknown, not absence, but says nothing about side effects, permissions, idempotency, or what recording changes in the system.

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 front-loaded sentence with no wasted words, and the parenthetical earns its place by clarifying the domain semantics. It is appropriately concise, though its brevity contributes to the gaps elsewhere.

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

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

An output schema exists, reducing the need to explain return values, but the tool has three undocumented parameters and no annotations. The description adds useful conceptual framing but leaves required parameter meaning and behavioral details incomplete.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters. The required feature and question fields and the optional recommended_probes field are left completely 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 states a specific action and domain concept: recording something that could not be observed, with the parenthetical clarifying that missing coverage means unknown rather than absence. It is clearer than a tautology, but it does not explicitly differentiate itself from siblings such as update_unknown or list_feature_unknowns.

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, no exclusions, and no mention of prerequisites. The parenthetical explains a semantic distinction, but it does not route the agent among the many 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?

Without annotations, the description carries the behavioral burden: it discloses strict mode requirements (approval of every finding, acknowledged coverage gaps), the alternative of rewriting prose findings, and standard mode refusal conditions. It does not cover permissions or reversibility, but provides rich gating behavior.

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

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

Front-loaded with the core action ('Release a draft through the gate') followed by mode-specific details. Dense but every sentence adds behavioral context; no wasted words.

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

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

Given an output schema exists and no annotations are present, the description covers the key gating behaviors and modes. It omits what 'gate' means operationally, but overall provides enough for an agent to call correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains accept_gaps meaningfully ('gives the reason they ship as unknowns'), but does not explain draft_id beyond its self-evident name. Adequate but not fully compensating.

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 ('Release') and resource ('a draft'), and explains the gating conditions. It distinguishes itself from siblings like approve_observed_output by focusing on releasing after approvals, though it does not explicitly name alternatives.

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

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

Explains when the tool succeeds in strict mode and when it is refused in standard mode, and mentions accept_gaps as a condition. It gives clear context for use but does not explicitly compare to siblings or state when to prefer this over review_spec.

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, and this is a mutation operation, so the description carries the full burden. It mentions requiring a reason and where to find rule IDs, but does not disclose whether retraction is permanent, what side effects occur, what permissions are needed, or what happens to dependent rules.

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 tight sentences with no wasted text. The core action is front-loaded, and the example and rule-ID hint are useful without bloating the definition.

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

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

Output schema exists, so return values need not be explained. But for a no-annotation mutation tool with three required parameters and zero schema descriptions, the definition is incomplete: the feature parameter is unexplained and behavioral consequences of retraction are 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 description coverage is 0%, so the description must explain all three parameters. It clarifies rule_id by saying IDs are in check_rules results and echoes that reason is required, but it gives no meaning at all for the feature parameter and adds little format detail for reason.

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 and resource: retract a rule. It also gives a concrete example of when a rule might be retracted and points to check_rules for rule IDs. It is clear, though it does not explicitly distinguish itself from list_rules.

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 implied usage scenario: a rule superseded by a reworded version. It also says rule IDs come from check_rules results. However, it does not state when not to use this tool or name alternatives such as list_rules.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the output shape (findings grouped by class, approval status, full prose findings) and implies a non-mutating dry run, which is genuinely useful. However, it never explicitly states that no state changes occur, whether a review record is persisted, what errors look like for an invalid draft_id, or any permission requirements — gaps that matter for a gate tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler, leading with the action and immediately qualifying it with the key constraint. It is dense with domain jargon ('the gate', finding classes), but nothing in it is wasted.

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

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

An output schema exists, so the description need not explain return values, and the one-parameter surface keeps the tool simple. Still, 'the gate' is a domain concept left undefined, and the failure/error path for an invalid draft is unaddressed. Adequate minimum for a low-arity tool, but not thorough.

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 for the single draft_id parameter — and it does not. 'On a draft' only loosely gestures at draft_id without clarifying whether it is a spec ID, version, or handle, or whether an unknown ID triggers an error. The description adds essentially no meaning beyond the bare string field.

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

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

States a specific verb+resource ('Run the gate on a draft') plus a scope qualifier ('without releasing it') that implicitly separates it from release_spec. An agent can tell this is a validation/dry-run tool, though the sibling that performs the actual release is never named, so differentiation is inferential rather than explicit.

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

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

The phrase 'without releasing it' implies this is the pre-release check, which is real usage guidance against release_spec. But it never says when the gate must be run, what happens if the gate fails, or how this differs from other validation-adjacent siblings like check_rules, coverage, or audit_verify. Usage is left to be inferred.

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

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

With no annotations, the description carries the full burden, and it does disclose the important side effect that the target is reset and that output has two layers (raw observations plus symbols). It does not say whether the reset is destructive to prior state, what happens on invalid inputs, or what 'symbols' actually contain, leaving real gaps for a state-mutating 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?

Two tight sentences, front-loaded with the core action, then optional-parameter modifiers. Every clause carries information, though the second sentence packs two modifiers together without separating them visually.

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

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

An output schema exists, so return values need not be described, which this description respects. However, for a tool that resets state and takes an undocumented required string array, the definition is missing the workflow context (target prerequisite, input format) needed to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It explains symbols_only and keys well, including a concrete example of key names, but the required 'inputs' parameter is never explained — an agent cannot tell whether these are action strings, selectors, or commands.

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

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

The description gives specific verbs and a resource flow: reset the target, apply inputs, return raw observations and symbols. An agent knows it executes a sequence of inputs against an already-open target. It stops short of explicitly naming which sibling tools feed it or overlap with it (e.g., discover_ui, probe_web_field).

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

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

There is no statement of when to use this versus siblings like discover_ui, suggest_probes, or probe_web_field. No prerequisites are given either, even though 'reset the target' implies a target must first be opened (open_target) and inputs must come from somewhere.

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

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

No annotations are provided, so the description bears the full behavioral burden. It does disclose one valuable trait — that a new mapper version is created rather than rules being edited in place — but it omits the destructive semantics of "replace" (what existing rules are lost), permission requirements, and whether prior versions remain recoverable. For a mutation with zero annotation coverage that is a substantial 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 compact sentences with the action and the resulting side effect front-loaded; every clause carries information 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?

A mutation tool with no annotations, 0% parameter coverage, and no sibling differentiation needs more than this. An output schema exists so return values need not be explained, but the missing guidance on required inputs, destructive scope, and when to prefer a targeted alternative leaves the definition incomplete for correct invocation.

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

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

Schema description coverage is 0% across three parameters. The description implies the content of `rules` via the drop/mask/rename/classify list, but says nothing about the `note` field or the `params` object, nor about the structure of individual rule entries. With all defaults (nothing required), an agent has no guidance on how much it must supply.

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

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

The description names a specific verb ("Replace") and resource ("mapper rules") and enumerates the rule kinds it covers (drop/mask/rename/classify), so the agent knows what is being written. It does not, however, position itself against nearby siblings such as list_rules, check_rules, or retract_rule, so fine-grained discrimination is left to inference.

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

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

There is no statement of when this tool should be used versus list_rules/check_rules/retract_rule, and no prerequisites (e.g., must rules be validated first, does this require a spec context). The word "Replace" only implies a write path; nothing tells the agent when a full replacement is preferable to a targeted retract_rule.

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

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

No annotations, so the description carries the burden. It does disclose the shape of the output (fault actions with a call-making path, probe_web_field argument sets, click paths), which tells the agent these are suggestions rather than executed probes. It does not state read-only behavior, side effects, cost, or whether suggestions are deduplicated against existing rules.

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

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

One dense sentence of scope plus one short sentence of sequencing, with no filler. Front-loaded with what the tool returns, which is the right ordering. Slightly list-heavy phrasing but every clause adds information.

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

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

An output schema exists, so return values need not be re-explained, and the description still usefully summarizes them. However, for a two-param tool with zero schema documentation, the missing meaning of 'feature' and 'limit' is a substantive gap an agent must guess at.

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 both parameters are undocumented anywhere. The description only implies that 'feature' scopes the gaps; it never says what form a feature identifier takes and never mentions 'limit' (default 30) at all, leaving half the surface unexplained.

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

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

States a specific action and resource: generating concrete next-step probes that target a feature's coverage gaps. The enumeration of three probe flavors (fault actions, probe_web_field arguments, click paths) makes the capability concrete and distinguishable from the sibling 'coverage' tool, though it never explicitly contrasts with it.

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

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

Gives explicit sequencing: run after discover_ui and after each batch of rules. That is a real when-to-use instruction an agent can act on. It stops short of saying when NOT to use it or naming the alternative (e.g., plain 'coverage') for a purely informational read.

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

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

With no annotations, the description carries the full burden, and it does disclose two real behavioral traits: resolved unknowns leave the release, and the audit log retains history. It omits whether reopening restores the unknown to the release, whether the operation is idempotent, and any permission requirements.

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, both earning their place: the first states the action and states, the second states the consequences. Front-loaded and zero waste.

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

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

An output schema exists, so return values needn't be explained, and the side effects on release/audit are covered. However, for a required status parameter with no enum and no schema descriptions, the missing enumeration of valid status values is a meaningful gap for correct invocation.

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

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

Schema coverage is 0%, so the description must define all three parameters. It mentions 'a note' and hints at status values, but never states which exact strings status accepts — 'reopen' reads as an action here, yet status is a required free-form string, leaving genuine ambiguity about valid 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 uses a specific verb (mark/reopen) plus the concrete resource (an unknown) and names the resulting states (resolved / out-of-scope / investigating). It is clearly distinguishable from record_unknown or list_feature_unknowns, though it never names a sibling explicitly.

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

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

It implies the right context — resolving, scoping out, or reopening an unknown — but never states when to use this versus record_unknown (create) or who is allowed to do it. The guidance is inferable rather than explicit, with no exclusions.

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