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

With no annotations, the description carries the full burden. 'Read-only' discloses the safety profile, and the guidance on inputs adds context, but it omits cost/tier behavior, caching (noCache), timeouts, or what the response looks like — all left entirely to the schema.

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

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

Three short sentences, front-loaded with the purpose, then the trigger, then the required inputs and safety note. 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?

For an 11-parameter tool with full schema coverage and no output schema, the description adequately covers purpose, trigger, and inputs. It leaves return-format and cost behavior to the schema, which is acceptable, though a note on the read-only/no-write guarantee relative to siblings would round it out.

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

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

Schema description coverage is 100%, so all 11 parameters are already documented in structured data. The description's mention of 'symptom, the error output and the few files involved' loosely maps to objective/paths but adds no syntax or detail beyond the schema, so baseline 3 applies.

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

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

The description states a specific goal (find the root cause of a bug or failing test), which an agent can act on. However, it does not distinguish itself from plausible siblings like gemini_analyze, quick_check, or codex_review, so an agent must infer which analysis tool applies.

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?

'Call it as soon as your first hypothesis fails' gives a concrete trigger condition for when to invoke it, and it specifies what to supply (symptom, error output, files). It stops short of naming alternatives or conditions to prefer a sibling instead.

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 the safety-relevant "Read-only" and the return shape (verdict plus ranked file:line findings validated against the files). However, it omits other meaningful traits: that results are cached by default (evidenced only by the noCache param), the cost/latency implications of tier selection, and any timeout behavior. Adequate but materially incomplete for an 11-param 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?

Four short sentences, front-loaded with purpose, then trigger, then return contract, then safety. No filler and each clause carries 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?

No output schema exists, yet the description compensates by naming the return contract (verdict plus ranked findings with file:line). It is nearly complete, with the residual gap being differentiation from the review siblings rather than any missing call mechanics.

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

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

Schema description coverage is 100%, so the schema already documents all eleven parameters including the tier semantics. The description's "a diff or a few files" loosely maps to diff/paths but adds no syntax, format or constraint detail beyond the schema; baseline 3 applies.

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

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

States a specific verb and resource (adversarial review of a diff or files) and names the engine (Codex), which is the exact axis that separates it from the sibling gemini_review. The scope is narrow and immediately understandable.

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?

"Use after any non-trivial change" gives a trigger condition, but the sibling set contains gemini_review, quick_check, security_audit and edge_cases, and the description never says when to pick this over those. It implies usage rather than routing the agent.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses 'Read-only' and describes the merged output shape (each verdict, agreements, disagreements), but says nothing about cost, latency, or auth implications of fanning out to three model families. Adequate but with real gaps.

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

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

Compact and mostly front-loaded: the mechanism and merge structure come first, then the use contexts, then the read-only note. No wasted sentences, though the opening could lead with the outcome rather than the process.

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 14-parameter tool with no output schema, the description covers the core purpose and describes what comes back (verdicts, agreement findings, disagreements). The tier/cost and path guidance lives in the schema. The main omission is any note on the expense or latency of a multi-family call.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters in detail. The description adds no parameter-level syntax or format beyond mentioning the three families, which the lanes enum already conveys. Baseline 3 is appropriate.

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

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

The description states a specific mechanism: the same question dispatched to Codex, Gemini and GPT-OSS in parallel and merged into a consensus verdict. This distinguishes it from single-model siblings like codex_review and gemini_review without naming them explicitly. Clear but not maximally differentiated.

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

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

It gives clear use contexts: risky changes, security-sensitive code, or a design you are unsure of. However, it offers no when-not guidance and does not route the agent away from overlapping siblings such as security_audit or plan_critique, so the alternative-selection guidance is incomplete.

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; 'Read-only' is a genuinely useful disclosure of side-effect profile. However it says nothing about cost/latency across the four tiers, whether code is ever executed, or how results are staged, all relevant for an 11-parameter analysis 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 sentences, zero waste: purpose first, usage trigger second, safety note third. Nothing padded, and the most decision-relevant information is 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?

For an 11-parameter tool with no output schema and no annotations, the description covers identity and one usage trigger but omits result format, cost/latency expectations, and how it relates to the other review tools. Adequate, not complete.

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

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

Schema description coverage is 100%, including detailed tier and objective semantics, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already documents.

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?

Strong specific verb+resource: it enumerates inputs and states the code mishandles and delivers them as test cases. That is a distinct niche from the sibling reviewers, though the description never names or contrasts any 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?

Gives a concrete trigger: use after writing logic involving branches, parsing, dates, money or retries. Clear context for when the tool applies, but no when-not guidance and no named alternative among quick_check/codex_review for overlapping cases.

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 meaningful traits: that failing models get paused (so the report reflects evolving state) and that credentials are never returned. It still does not state whether the tool is read-only or requires any auth, but for a zero-parameter status probe the disclosure is substantive.

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

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

Two sentences, front-loaded with the report contents and closed with the caller condition and the credential guarantee. No filler and every clause carries 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?

There is no output schema, so the description must convey what comes back, and its four-part enumeration does that adequately for a no-argument status tool. It could be tighter on when the paused/limit state applies, but an agent has enough to call it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The enumeration of report contents is a bonus rather than a compensation for missing parameter documentation.

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

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

The description enumerates precisely what the tool surfaces: installed/signed-in CLIs, per-tier model assignment, paused models, and active limits. That is a concrete, specific purpose rather than a restatement of the name. It stops short of 5 because there is no explicit verb and no differentiation from the nearest sibling, quick_check, which an agent could plausibly confuse it with.

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?

'Call it after a failed call' gives a clear triggering condition rather than leaving usage to inference. It does not name an alternative or state when not to call it (e.g., quick_check for a cheap pre-flight), so it falls short of full routing guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it does supply the single most important trait: 'Read-only.' That is a genuine, useful behavioral commitment. However, it says nothing about the fact that this dispatches work to an external specialist model, the cost/latency implications, or caching behavior (params like tier/model/noCache hint at this but the description is silent).

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

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

Three terse fragments with no filler, and the usage trigger and safety note are packed into minimal space. The opening phrase is a noun clause rather than a front-loaded verb, which slightly weakens scannability, but overall it is efficiently sized.

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 11-parameter tool with no output schema and no annotations, so the description must carry more weight than it does. It omits what the tool returns, that it delegates to an external LLM specialist (with cost implications), and how it relates to the sibling analysis/review tools, leaving meaningful gaps for an agent deciding whether and how to call it.

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

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

Schema description coverage is 100% across 11 parameters, so the schema already explains diff, tier, model, paths, checks, workdir, objective, timeoutMs and constraints thoroughly (e.g. the tier enum guidance). The description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The fragment 'How a broad or unfamiliar part of the code fits together' implies a code-comprehension/analysis function, but it never uses a verb+resource construction to state what the tool actually does. It also offers no differentiation from the many sibling review/diagnose tools (gemini_review, codex_review, codex_diagnose, edge_cases), so an agent must infer the boundary from the name alone.

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

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

The trigger 'Use before editing code you have not read' is a concrete, actionable condition that tells the agent when this tool applies. It stops short of naming alternatives or stating when-not-to-use (e.g. versus gemini_review), so it is clear context without 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 burden. It discloses read-only status and its focus areas, and the schema adds that the workdir is read-only and nothing above it is read, but the description omits auth needs, cost/rate implications, and what the review returns. Adequate but thin for an annotation-free 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 short, front-loaded sentences with no filler; the purpose leads and the read-only trait is stated compactly. Terse, though it trades some completeness for brevity.

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

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

For an 11-parameter review tool with no output schema and no annotations, the description covers the role and focus but leaves behavioral details (auth, cost, return format) to the schema or unstated. Reasonable but with clear gaps.

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

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

Schema description coverage is 100%, so every parameter (tier, model, diff, paths, checks, objective, constraints, etc.) is already documented in the schema. The description adds nothing parameter-specific, so the baseline 3 applies.

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

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

States that this is a review by Gemini and names its strong areas (interface contracts, error paths, state, user-facing regressions), which gives a real sense of what it does. However, it never explicitly states the verb+resource ('reviews your code/diff') nor names the sibling it complements (codex_review, gemini_analyze), so differentiation is only implicit.

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?

'Second review' implies it is used as a follow-up pass, and the listed strengths hint at when to prefer it, but there is no explicit when-to-use/when-not or named alternative such as codex_review or gemini_analyze. Usage is left to inference.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose 'Read-only' and that it operates before code is written. However it omits cost/latency behavior, caching semantics, and what the critique actually returns; the cost tradeoffs are relegated entirely to the tier parameter's schema text rather than the description itself.

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 zero waste: the scope of the critique is front-loaded, followed immediately by the usage trigger and a one-word safety disclosure. Every fragment earns its place.

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

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

For a 12-parameter tool with full schema coverage and no annotations, the description supplies purpose, scope, usage condition, and the critical read-only guarantee. The notable gap is that, with no output schema, it never hints at what the critique returns (format, structure, actionable findings).

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters (tier, workdir, effort, etc.). The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (critique) and resource (an implementation plan) and enumerates the kinds of issues it surfaces (wrong assumptions, missing steps, simpler paths, production risks). The phrase 'before any code is written' implicitly distinguishes it from the review siblings, though no sibling is named 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?

Gives a concrete trigger: 'Use on any task that touches more than one file.' That is a clear condition for invocation. It stops short of naming alternatives (e.g. codex_review for written code) or stating when NOT to use it, so it is not a full 5.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key behavioral trait ("Read-only"), which is valuable, but says nothing about what is returned, that results are cached, or the cost/latency implications of the tier system — significant gaps for an 11-param tool with no 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?

Two short sentences, front-loaded with the scope, with no filler. Every clause carries information an agent can act on.

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 11 parameters, no annotations, and no output schema, the description is thin relative to the tool's complexity — it never says what the specialist returns or in what form. The 100% schema coverage compensates for parameter gaps but not for the missing behavioral/return context.

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

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

Schema description coverage is 100%, so every parameter including tier, workdir, and checks is already documented in the schema. The description's artifact list loosely maps onto paths/diff but adds no syntax or selection guidance beyond the schema, so the baseline of 3 applies.

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

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

States a concrete purpose: a fast, cheap "second look" scoped to small artifacts (function, regex, query, config value, one-file change). This contrasts implicitly with heavier siblings like codex_review or security_audit, but no sibling is named 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?

"Cheap and quick; use it often" is a genuine usage directive, and the enumerated small-artifact list bounds when it applies. However, it never says when NOT to use it or which alternative to pick for larger changes, leaving the routing decision to inference.

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

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

No annotations are provided, so the description carries the full burden. It discloses one important trait, 'Read-only', but says nothing about cost/model spend, caching, per-attempt time budget, or the shape of the result. The schema's workdir description also states it reads nothing above the root and writes nothing, so 'Read-only' is partly redundant with structured data; the description adds a little but leaves the behavioral picture thin for an 11-parameter 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?

Three short telegraphic sentences: what it finds, where to use it, and the read-only guarantee, with the issue classes front-loaded. There is no filler. The fragmented list style trades a little readability for density, which keeps it just under a 5.

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

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

For a complex 11-parameter tool with 100% schema coverage and no output schema, the description covers purpose and when-to-use but omits anything about how it differs operationally from codex_review/gemini_review or what the agent gets back. Given the schema covers parameters fully and no output schema exists, the remaining gap is sibling differentiation, so an adequate-but-not-complete 3.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters thoroughly (tier semantics, workdir sandboxing, objective, checks). The description adds no syntax, format, or defaults beyond that. Baseline 3 is correct when the schema does the heavy lifting.

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

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

It states a specific domain: finding exploitable security issues, and enumerates the classes it covers (injection, authz gaps, secrets, SSRF, path traversal, races, client-input trust). That is enough to distinguish it from the generic review siblings (codex_review, gemini_review) and the structural siblings (edge_cases, plan_critique) without naming them. It is a noun-phrase list rather than a clean verb+resource, but the purpose is unambiguous.

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

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

It gives concrete triggers: use on auth, payments, user input, file paths, shell commands. That is a clear context-of-use. It stops short of explicit exclusions or naming the sibling to pick instead when the question is not security-relevant, so it is not a 5.

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