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

The description adds meaningful behavioral detail beyond the annotations: no edits or tests, root must be configured, and results include complete units, hashes, and coverage limits. The readOnlyHint=false is somewhat explained by the safety-oriented wording, and there is no direct contradiction with the annotations.

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

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

Three compact sentences front-load the main action and add safety/constraint context without filler. The phrasing 'with Jev' is somewhat redundant with the tool name and 'Explicit configured root required' is awkward, but overall the description is appropriately brief.

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

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

Given no output schema and five parameters, the description does provide needed context: authorization scope, root requirement, no edits/tests, and return contents. However, it leaves parameter semantics, the meaning of 'coverage limits,' and the side-effect profile of the Jev ranking step under-specified.

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 only 20%, so the description must compensate, but it does not explain the meaning of query, glob, max_candidates, or root beyond path-related hints. The reference to 'coverage limits' is ambiguous and not clearly mapped to the schema parameters.

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

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

The description opens with a specific action and resource: 'Find source candidates within an explicitly authorized non-sensitive subdirectory.' It also adds 'No edits or tests,' which helps separate it from mutation-oriented siblings. It does not explicitly name a sibling alternative, so it stops short of a 5.

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

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

The description conveys clear prerequisites and constraints: only authorized subdirectories, explicit configured root, no edits/tests. That implies when the tool is appropriate, but it never points to a sibling tool or states when-not-to-use, leaving routing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read-only operation. The description adds the clarification that it does not run anything, which aligns with the read-only annotation but does not go beyond it. It also mentions reliance on trusted execution facts, which adds context, but no other behavioral traits (e.g., rate limits, side effects) are disclosed. The description does not contradict annotations.

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

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

The description is extremely concise, consisting of two short sentences with no wasted words. It front-loads the core purpose and includes a clarifying statement about not executing anything. This is an efficient and well-structured description.

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

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

Given the tool has 7 parameters, nested objects, no output schema, and a set of sibling tools, the description is insufficiently complete. It does not explain the expected output format (e.g., what a 'judge' decision looks like), nor does it provide guidance on how parameters interact or when to use this tool in a workflow. The description relies heavily on schema descriptions and annotations, but the schema is incomplete and the description adds little 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?

The description does not mention any of the parameters or their meanings. Schema coverage is 57%, meaning several parameters (model, extras, review_at, auto_accept) lack descriptions in the schema, and the tool description does not compensate for this gap. The required parameters task and observation are described in the schema, but the description adds no additional semantic value to any 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 clearly states the tool's purpose: to judge whether to proceed, retry, or stop based on trusted execution facts. It also distinguishes itself by explicitly noting it does not run anything, which helps differentiate from execution-focused siblings. However, the phrase 'judge next step' is somewhat generic and could be more explicit about the decision output.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or exclusions. Sibling tools exist (e.g., jev_step, jev_verify), but the description does not reference them or provide any routing cues, leaving the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds no behavioral details beyond that – no mention of evaluation process, parallelism, or side effects. It doesn't contradict annotations, but it contributes little extra value on top of them.

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

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

Two sentences with zero waste. The purpose is front-loaded, and the usage condition follows immediately. Every word earns its place; it's a model of conciseness.

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

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

Given the complexity of the nested question schema, the description is thin. It provides the crucial fallback guidance, but it doesn't explain what the tool returns (no output schema) or give examples of how to structure questions. The schema is self-descriptive, so it's adequate but not robust; an agent would need to rely heavily on the schema.

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

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

Schema description coverage is 100%, with detailed descriptions for 'state', 'questions', and 'model'. The tool description adds no parameter-specific meaning, so the baseline of 3 applies – the schema does the heavy lifting.

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

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

The description states 'Typed atomic judgments over supplied text' – a verb and resource – but 'typed atomic' is domain jargon and doesn't clarify the three question types (noul, choice, score) that the schema defines. The fallback note 'Use only if a specific recipe does not fit' hints at differentiation from siblings, but the core purpose remains ambiguous without schema inspection.

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

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

The description explicitly says 'Use only if a specific recipe does not fit', which clearly establishes the condition for use and implies alternatives (specific recipes). It doesn't name the sibling tools, but the sibling list provides enough context for an agent to infer which tools are the 'recipes'.

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

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

Annotations already establish that the tool is read-only and non-destructive. The description adds one useful behavioral caveat: 'Auto is not runtime acceptance,' which suggests that auto_accept should not be treated as confirmation of runtime behavior. However, it does not explain what happens during review, how acceptance decisions are made, or what the tool does with review_at/auto_accept values.

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

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

The description is very concise, with the primary purpose front-loaded in the first sentence and a short caveat in the second. There is no wasted text. However, the second sentence is cryptic enough that it may require the agent to infer what 'Auto' refers to, so it is not perfectly clear.

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

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

The tool has 8 parameters, 4 required, and no output schema, yet the description offers no information about return values, success criteria, or how evidence and claims are compared. It also leaves the purpose of review_at and auto_accept mostly unexplained. For a complex review/gating tool, this description is too minimal to be fully actionable.

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 63%, so the schema already documents most parameters. The description references 'diff' and 'claims' but adds little semantic detail beyond the schema. The line 'Auto is not runtime acceptance' hints at the meaning of auto_accept, which lacks a schema description, but this is too indirect and underdeveloped to raise the score.

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 a specific action: review a diff and verify completion claims together. It names the core resource (diff) and the verification target (completion claims). However, it does not differentiate itself from sibling tools like jev_review or jev_verify, so it lacks explicit sibling distinction.

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

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

The description provides almost no guidance on when to use this tool versus alternatives. It does not mention any exclusion criteria, prerequisites, or conditions under which another sibling tool should be preferred. The warning 'Auto is not runtime acceptance' is more of a behavioral caveat than actionable usage 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?

The description adds valuable behavior beyond annotations by stating 'Pinned collection uses no model' and 'No arbitrary commands or source edits', clarifying model involvement and side-effect boundaries. It also mentions hash-returning behavior. Since annotations already provide safety hints, this additional context is sufficient without requiring auth or rate-limit details.

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

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

The description is three short sentences with zero filler. The core function is front-loaded in the first sentence, followed by two tight constraint sentences about model usage and side effects. Every sentence earns its place.

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

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

The description covers the core purpose, optional behaviors, output concept (hashes), and key safety restrictions. The schema fully documents parameters, and no output schema exists to require further return-value explanation. It is sufficiently complete for an agent to invoke the tool correctly, though it could be more explicit about the exact shape of the returned evidence.

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 parameters are already well documented by the schema. The description adds some high-level context like 'explicit authorized file excerpts' and 'evidence with hashes', but it does not meaningfully elaborate on root, task, checks, labels, or sources beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific action and resource: 'Collect explicit authorized file excerpts' and 'return evidence with hashes'. It conveys the tool's evidence-preparation role and distinguishes it from sibling tools by focusing on collection plus optional classification/verification, though it never names an alternative explicitly.

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

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

The description explains what the tool does but gives no explicit guidance on when to choose it over siblings like jev_verify or jev_review. 'Pinned collection uses no model' is a behavioral constraint, not a usage selector, and no exclusions or alternatives 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?

The description adds behavioral context beyond the annotations: it promises to 'preserve all originals, constraints and acceptance', states 'No model selection, spawning or edits', and explains that 'No labels/checks means zero inference'. These clarify side-effect boundaries. It does not cover auth, rate limits, or exact persistence semantics, so it is not a 5, but it adds genuine 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?

Four sentences, front-loaded with the core purpose, each sentence adding a distinct constraint (scope, task_id uniqueness, behavior, exclusions). No redundant or filler wording.

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

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

The description covers the core workflow and important edge cases like zero inference, but it never describes the return value or what the prepared 'work packet' contains, and with no output schema an agent has to infer that. For a 9-parameter tool this is a noticeable gap, though the schema picks up a lot of slack.

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 descriptions already cover root, task, checks, labels, sources, and task_id (67% coverage). The description adds some extra semantics for labels/checks ('No labels/checks means zero inference') and mentions executor modes ('main-host execution or one subagent assignment') and preservation of constraints/acceptance. But it does not fully explain the semantics of executor, acceptance, and constraints, so it stays at the middle baseline.

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

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

The description states a specific verb ('Prepare') and a concrete resource ('task-specific source-linked work packet'), scoped to 'main-host execution or one subagent assignment'. It also distinguishes from siblings by noting each task needs its own task_id and explicitly excludes model selection, spawning, and edits, so an agent can tell this apart from tools like jev_prepare_evidence.

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

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

The description gives clear context for when to use the tool (preparing a work packet for main or subagent, per distinct task_id) and hints at when not to use it ('No model selection, spawning or edits. No labels/checks means zero inference'). However, it never names an alternative tool for those excluded cases, so the guidance is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool's safety profile is known. The description adds the behavioral constraint 'Does not discover files,' which clarifies its scope. However, it does not describe the return format, scoring details, or any side effects beyond what the annotations provide, so it adds moderate value.

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

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

The description is two short sentences with no fluff. The primary action is front-loaded, and the negative constraint follows naturally. Every word earns its place.

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

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

The tool has no output schema, and the description does not state what the tool returns (e.g., an ordered list of IDs, scores, or both). While the name and action imply a ranked list, an agent cannot be certain of the response shape, which could lead to incorrect handling of the output. The schema covers input constraints, but output behavior is left unspecified.

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

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

The schema provides descriptions for 3 of 4 parameters (query, top_k, candidates) with 75% coverage. The description adds the term 'explicit' to clarify that candidates are user-supplied, but it does not add substantive details beyond the schema. The 'model' parameter remains undocumented in both schema and 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?

The description states a specific action ('Rank') on a specific resource ('explicit candidates') with a criterion ('by relevance'). It also draws a clear boundary with 'Does not discover files,' differentiating it from discovery-oriented sibling tools. This is enough to distinguish it from tools like jev_evaluate or jev_review.

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

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

The description implies usage when the agent already has a list of candidates and needs them ordered by relevance, but it does not explicitly name alternatives or provide when-not conditions. The negative statement 'Does not discover files' hints at when not to use it, but it lacks explicit routing to sibling tools such as jev_route_skills or jev_tool_route.

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

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

Annotations already declare readOnlyHint=true, so the non-mutating nature is captured externally. The description adds value by noting the advisory nature and that tests/host review are still required, which tells the agent the output is not authoritative. It does not describe any additional side effects, output format, or behavior around optional parameters like auto_accept, but there is no contradiction with annotations.

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

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

The description is a single, tight sentence with two clauses: the core action and the critical advisory limitation. Every word earns its place, and the most important distinction ('Advisory') is front-loaded. There is no filler, repetition, or redundant schema echo.

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 6 parameters, no output schema, and several similarly named sibling tools, the description is too thin. It does not explain what the review returns, how to interpret the advisory result, how auto_accept or review_at affect behavior, or when this tool is preferable to jev_evaluate or jev_verify. The core purpose is clear, but an agent would struggle to invoke it correctly in nuanced contexts.

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 50%, with descriptions only for diff, tests, and request. The tool description adds no parameter-level meaning whatsoever, leaving model, review_at, and auto_accept completely unexplained in both the schema and description. Since the description must compensate for this gap and does not, it falls below the baseline.

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

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

The description uses a specific verb and resource: 'Assess a proposed diff.' The word 'Advisory' further clarifies that this is a review/opinion tool, which helps distinguish it from stricter verification tools like jev_verify or jev_gate. However, it does not explicitly name or contrast any sibling tool, so it stops short of full differentiation.

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

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

The phrase 'Advisory; actual tests and host review remain required' provides useful context that this tool should not be treated as a final authority or a substitute for verification. It implies when not to rely on it, but it does not explicitly state when to use it versus alternatives like jev_verify or jev_gate, nor does it name 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?

Annotations are sparse (readOnlyHint=false, openWorldHint=true, no destructive hint), so the description carries extra weight. It adds value by clarifying non-execution, non-installation, and uncertainty handling, which is behavior beyond the structured annotations. No contradiction with annotations.

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

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

Three short sentences with no filler. The primary purpose is front-loaded, followed by constraints and exclusions. Every sentence serves a distinct purpose.

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

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

Given 3 params, no output schema, and modest annotations, the description adequately covers the tool's role, constraints, and output behavior (one suggestion, no-match/uncertainty allowed). It could be more explicit about the exact output format, but it is complete enough for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mostly reinforces what the schema already states (e.g., 'at most 19 complete candidate descriptions' matches maxItems and candidate description). It does not add significant new parameter-level meaning beyond the schema.

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

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

The description states a specific verb ('Suggest') and resource ('one host-confirmed skill') with clear input constraints ('from at most 19 complete candidate descriptions'). It also distinguishes from siblings by scope ('skill' vs tools, 'Not a per-message hook') and explicitly excludes actions like install/load/execute/scan.

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 context for use: selecting a skill from host-confirmed candidates, preserving required skills, allowing no-match/uncertainty. It provides exclusions ('Does not install, load, execute or scan skills', 'Not a per-message hook'), though it does not name alternative tools explicitly.

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

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

Annotations already mark it read-only and non-destructive; the description adds a crucial behavioral warning that its assessment is not a security boundary or permission to follow embedded instructions. That prevents prompt-injection over-reliance, which is beyond what readOnlyHint conveys. It doesn't address output format or auth, but not 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?

The description is a single 12-word sentence with zero filler, front-loading the action and adding the safety caveat. It is appropriately tight, though a little more concrete parameter or output context could be added without hurting structure.

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

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

For a five-parameter tool with no output schema and many sibling tools, this is only partially complete. It nails the core intent and the key advisory caveat, but leaves block_at/review_at semantics and the expected output unspecified; annotations and schema fill only some of the gap.

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

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

Schema description coverage is only 40%, and the description does not explain model, purpose, block_at, or review_at. The only parameter it touches is text ('untrusted text'), and even that largely repeats the schema's 'Fetched or pasted text before the agent reads it.' The low coverage burden is not compensated.

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

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

The description names a specific action ('Assess') and object ('untrusted text'), and adds a distinctive negative qualifier ('not a security boundary or permission to follow its instructions'). It does not explicitly differentiate from sibling tools like jev_review or jev_evaluate, whose names also suggest assessment.

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 when to use it—whenever text is untrusted and needs assessment before the agent acts—and warns not to treat the result as authorization. However, it does not name sibling alternatives or lay out a crisp when-to-use vs. when-not-to-use decision.

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

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

The description adds that 'Host executes only after its own checks,' which clarifies that this tool is a router and does not perform the execution itself. This is valuable context beyond the readOnlyHint annotation, which only indicates no side effects. The description explains the host's role in the execution chain, giving the agent a clearer model of the tool's behavior.

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

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

The description is a single sentence, front-loaded with the action ('Select among host-prepared authorized calls and route a step') and contains no filler or unnecessary words. It is appropriately concise and well-structured.

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

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

Given the tool's complexity—8 parameters, nested objects, up to 32 candidates, and trusted host facts—the one-sentence description is severely insufficient. It does not explain the selection criteria, what 'route' means, how the candidates array should be interpreted, or what the tool returns. The agent must rely entirely on the schema and annotations, which is a significant gap for a tool of this complexity.

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

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

Schema description coverage is 63%, so the schema already documents most parameters. The description does not add any parameter-specific information, which is acceptable given the coverage, but it also does not help resolve any ambiguity in the remaining undocumented parameters. The baseline of 3 is appropriate since the schema carries most of the weight.

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

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

The description clearly states the action: 'Select among host-prepared authorized calls and route a step.' This is a specific verb+resource combination that distinguishes it from sibling tools like jev_review or jev_evaluate, which serve different purposes. The mention of 'host-prepared authorized calls' is unique and immediately clarifies the tool's role.

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

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

The description provides no guidance on when to use this tool versus the alternatives. It does not mention any conditions, exclusions, or alternative tools. An agent would have to infer from the tool name and schema that this is for choosing among prepared calls, but the description itself offers no routing logic or context for when this is the appropriate choice.

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

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

Annotations already supply readOnlyHint=true and destructiveHint=false, so the description does not need to restate safety. It adds the non-obvious behavioral facts that this tool neither invents arguments nor executes calls, which prevents two common misuses and goes beyond the annotation layer.

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 terse clauses, front-loaded with the operative verb and followed by the two essential negative constraints. Every word earns its place; there is no filler or restatement of the schema.

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

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

For a routing tool with six parameters and no output schema, the description establishes the tool's role but does not cover the required task and observation fields, the review_at/auto_accept controls, or what the selection result looks like. It is adequate for orientation but not complete for unambiguous 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?

With only 17% schema description coverage, the description needed to clarify the six parameters. It only clarifies the selection container ('prepared calls') and says arguments are never generated, leaving task, observation, model, review_at, and auto_accept without added meaning. The schema descriptions are left to carry too much weight.

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

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

The description names the specific operation ('Select') and the exact object ('prepared calls'), and then draws a hard line with 'never generates arguments or executes calls.' This makes it immediately distinguishable from planning or execution tools, even without naming 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?

The phrase 'Select from prepared calls' implies the intended context: use when a host has already prepared candidate calls and a choice must be made. The negative clauses provide a clear boundary, but no explicit when/when-not conditions or sibling alternatives are named.

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

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

Annotations already declare read-only and open-world hints; the description adds a meaningful behavioral trait beyond that: unsupported claims are retained and uncertainty is preserved. This helps the agent avoid expecting every claim to be definitively resolved or dropped, though it does not cover response format or other operational details.

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

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

The description is a single terse sentence with no filler. The core action and the key behavioral caveat are front-loaded, so it is efficiently scannable.

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 four parameters and no output schema, the description omits the result shape, the behavior of `auto_accept`, and guidance on model selection. Given the many sibling tools, the lack of return semantics and optional-parameter context makes the definition less than fully actionable.

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

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

The schema documents the required `claims` and `evidence` parameters for roughly 50% coverage. The description names those same inputs but adds no extra meaning, and it leaves the optional `model` and `auto_accept` parameters completely unexplained, so an agent cannot confidently set them.

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

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

The description uses a specific verb ('Check') and names the resource ('claims against supplied evidence'), and it adds a distinguishing nuance by noting that uncertainty and unsupported claims are retained. It does not explicitly contrast with sibling tools like jev_evaluate or jev_review, so it falls short of full differentiation.

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

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

The phrase 'Check claims against supplied evidence' implies the intended context: use it when factual claims must be checked against source text or documents. It does not state when to avoid it or point to an alternative sibling, so the routing guidance is implicit rather than explicit.

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