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

With no annotations provided, the description carries the behavioral disclosure burden. It does well by exposing non-obvious behavior: it respects robots.txt, follows each source's off-hours crawl window, and allows a force bypass. It does not detail database write semantics, runtime expectations, or the exact scope of force, but the core side effects are disclosed.

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

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

A single sentence front-loads the core action and constraint, then packs the source list and force caveat without redundancy. Every clause contributes either action, scope, or a behavioral condition.

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 network-crawling tool with no output schema and no annotations, the description offers enough to select and invoke it: what it crawls, where it writes, and which switch changes scheduling behavior. It does not describe return value shape or warn about long-running/network-heavy execution, but the essential operation is clear.

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 explains all six parameters. The description adds a little extra context by tying force=true to the off-hours bypass and listing the exact source ids, but it does not substantially deepen parameter meaning beyond the schema.

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

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

The description opens with a specific verb ('crawl'), names the exact resource (11 curated sources), and states the destination ('local SQLite+FTS5 research hub'). It clearly differentiates hub_crawl from sibling read-only tools like hub_query and hub_stats by describing an ingestion/population action.

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 clear context: use this tool to populate the local research hub from a defined set of external sources, with politeness constraints. It does not explicitly say 'use hub_query for reading' or list when not to use it, so it stops short of full exclusion guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently describes the multi-stage pipeline: FTS5 search, relevance re-ranking, evidence tiering, and synthesis into a cited answer. It does not state read-only behavior or return details, but for a query-and-synthesize tool this is reasonably complete.

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 search behavior and then covers the re-ranking and synthesis steps. It is efficient, though the tail phrase 'grounds claims in mental models and cognitive-science findings over popular advice' is slightly awkward and could be tighter.

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, but the description explicitly indicates the answer form (cited, step-by-step) and the tiering scheme, which is enough for an agent to anticipate the result. All parameters are documented in the schema. An example or explicit return structure would improve completeness, but it is not essential for invoking the tool.

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

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

Schema description coverage is 100%, so the parameters are already documented in the input schema. The description adds context about FTS5 search and re-ranking that helps explain why topK and limit matter, but it does not add meaning beyond what the schema already conveys for most parameters.

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

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

The description clearly names the resource (crawled research hub), the mechanism (FTS5 search re-ranked into VERIFIED/PROBABLE/REJECTED tiers), and the output (a cited, step-by-step synthesized answer). It does not explicitly contrast with a sibling like jev_research, but the specificity is strong enough that an agent can tell 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?

Usage context is implied: this is for research questions where claims should be grounded in mental models and cognitive-science findings rather than popular advice. However, there is no explicit when-to-use versus alternatives, and the description does not mention conditions that should route the agent to a different tool.

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 present, so the description carries the full burden. 'Report' implies a non-mutating read operation and the description discloses the output dimensions, but it does not explicitly promise read-only behavior or describe failure/error cases. For a low-risk statistics tool this is acceptable, though not rich.

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 focused sentence that front-loads the verb and the specific metrics being reported. There is no filler, repetition of the title, or boilerplate, making it efficient and easy to parse.

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

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

For a tool with one optional parameter and no output schema, the description clearly enumerates the returned information: document counts, word totals, and last-crawl timestamps per source. Minor gaps exist around what 'source' means and an explicit read-only guarantee, but the overall simplicity means an agent can invoke the tool with confidence.

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%, since the only parameter, dbPath, is already documented as an alternative SQLite path with a default. The tool description adds no additional parameter meaning 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?

The description names a specific verb ('Report') and concrete output metrics ('document counts, word totals and last-crawl timestamps per source'), so an agent knows exactly what this tool produces. This also distinguishes it from sibling tools like hub_crawl and hub_query, which focus on crawling or querying rather than aggregate statistics.

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 that the tool should be used when aggregate counts, totals, or crawl timestamps are needed, but it never explicitly states when to use it versus alternatives. There is no when-not-to-use guidance or routing to sibling tools, so usage context remains only implied.

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

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

With no annotations provided, the description carries the full burden, and 'Scan a project directory' reasonably implies a read-only analysis rather than a mutation or destructive action. It also discloses the output shape (findings, evidence, ranked fix actions), but it does not state whether any side effects, network calls, or permission requirements exist.

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 with no filler. Every phrase adds value: the action, the target, the five scored dimensions, and the expected deliverables are all included economically.

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 audit tool with no output schema and no annotations, the description covers the core purpose and output categories, but leaves gaps around when to use it versus sibling tools, practical limitations, and safety/impact expectations. It is sufficient for a basic invocation but not fully self-contained.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description reinforces that 'root' is a project directory, but adds no additional meaning beyond the schema, such as format constraints, default behavior of 'preset', or relationships between 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 uses a specific verb ('Scan'), names the target resource ('a project directory'), and precisely defines the domain ('score five dimensions') and the deliverable ('findings, evidence and ranked fix actions'). This clearly sets jev_audit apart from sibling tools like jev_research or jev_redteam, which have different scope and outputs.

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

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

The intended use case is implied: run a comprehensive diagnostic audit of a project directory. However, there is no explicit 'use this when' guidance, no comparisons to sibling tools like jev_evaluate or jev_redteam, and no exclusions, so an agent must infer when this is the right choice relative to the many alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly lists what information is reported, which implies a read-only introspection tool, but it does not explicitly state that the operation has no side effects, nor does it describe output structure or potential authorization/availability caveats. The description is adequate but not deeply transparent.

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

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

The description is a single well-structured sentence that front-loads the verb and immediately enumerates the concrete outputs. It includes the purpose clause without redundancy or filler. Every element contributes to letting an agent understand what this tool reports and why it would use it.

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 simple zero-parameter informational tool with no output schema, so the description reasonably outlines the main return categories: backend chain, pricing, gatekeeper policy, presets, memory summary, and workspace paths. It does not detail output formatting or edge cases, but for an introspection tool of this simplicity, the provided context is largely sufficient.

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

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

The tool has zero parameters and an empty input schema, so the baseline is 4 per the rubric. The description needs to convey no parameter meaning because there is nothing to configure; it instead meaningful lists the information domains returned. There is no gap for the description to fill.

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 the specific verb 'Report' and enumerates the exact resources covered: backend chain, pricing, gatekeeper policy, presets, memory summary, and workspace paths. It clearly frames the tool as a setup-diagnostics operation, which distinguishes it from sibling decision/evaluation tools like jev_evaluate, jev_decide, and jev_plan.

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 states the target use case explicitly: 'so agents can self-diagnose the setup.' This gives a clear contextual trigger for invoking the tool, though it does not name alternatives or state when not to use it. Given the sibling list, the diagnostic intent is enough to guide selection for most agents.

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

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

With no annotations, the description carries the burden. It discloses that the operation is lossless, preserves specific elements, and costs nothing. However, it doesn't clarify whether the tool modifies files in place or returns new text, nor does it describe error handling or side effects. This is a partial disclosure.

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

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

The description is two sentences with no filler, front-loading the core action. It's efficient but slightly dense; the list of preserved elements is detailed but necessary.

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

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

Without an output schema or annotations, the description leaves ambiguity about return values and file mutation behavior. It doesn't explain the relationship between the `text` and `file` parameters, nor does it specify what the tool returns. This is a significant gap for a tool with 5 parameters.

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

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

All parameters have descriptions in the schema (100% coverage), so the description adds minimal extra meaning. It reinforces the goal and losslessness but doesn't explain parameter interactions or defaults beyond what the schema already provides.

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

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

The description clearly states the tool's function: deleting irrelevant lines while preserving specific elements like paths, commands, error codes. It distinguishes itself from summarizing by emphasizing losslessness, but it doesn't explicitly differentiate from sibling tools like jev_rerank or jev_privacy_sanitize, so it's clear but not sibling-specific.

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

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

The description implies when to use it—when you need to compact context losslessly without summarizing—but it doesn't provide explicit exclusions or alternative tool references. The mention of 'log/grep/diff lines' gives context but no guidance on when not to use it or which sibling to choose 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 behavioral disclosure burden. It transparently describes the three execution branches, the $0 direct-execution path, speculative sub-decisions, and System 2 escalation. It does not disclose output format or side effects, but the persist parameter and schema cover part of that.

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 dense sentence with a front-loaded action and a colon-structured breakdown of the three confidence branches. Every clause contributes behavioral 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?

The description covers the core routing behavior but does not explain what value the tool returns, what 'speculative sub-decisions' look like, or how an agent should consume the result. Since there is no output schema and no annotations, these gaps reduce completeness even though the main purpose is clear.

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 four parameters. The description adds no parameter-level meaning beyond the general notion of confidence routing, so the baseline 3 is appropriate.

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

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

The description names a specific action ('Route one decision') and resource (the BELKİ gatekeeper), and clearly enumerates the three confidence-based outcomes. It is self-explanatory, but it does not explicitly contrast itself with sibling tools such as jev_evaluate or jev_verify, so differentiation is implicit rather than direct.

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 three confidence bands describe the tool's internal routing rather than when an agent should choose this tool over alternatives. Usage is implied ('Route one decision through...') but there are no explicit conditions, exclusions, 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 burden of behavioral disclosure. It reveals that the tool reads shared memory and task intent, which is useful, but it does not say whether this operation mutates shared memory, has side effects, requires prior state, or only constructs a payload. The nature of the dispatch side effects remains unclear.

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 behavior first and the output second. It packs the role list and handoff payload without irrelevant detail or repetition, earning every word.

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 conveys the high-level operation and output concept, but with no output schema it does not specify what 'ready handoff payload' actually looks like structurally. It also does not state what happens if no role is appropriate or how shared memory content influences the pick. These are notable gaps given the tool's orchestration role.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal context by mentioning task intent and shared memory, which loosely maps to the 'task' and 'context' parameters, but it does not materially deepen the meaning beyond what the schema already states.

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

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

The description uses a specific action ('Read shared memory + task intent and pick the next agent role') and names the exact output ('ready handoff payload'). It also lists the candidate roles, making the tool's function unambiguous and differentiating it from sibling tools like jev_evaluate or jev_plan, which route to judgment or planning rather than role dispatch.

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 the tool is used when a task needs to be routed to the next agent role, especially after considering shared memory and task intent. However, it does not explicitly state when to prefer this over siblings, nor does it provide exclusions or conditions such as 'use this only when a role handoff is needed rather than evaluating or planning.'

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 the main side effect: optionally writing the axolotl YAML to artifacts/training. It also states the output content (axolotl/unsloth + vLLM recipe). It stops short of detailing overwrite behavior or whether the recipe is returned in-band, but the key behavioral trait is transparent.

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

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

A single front-loaded sentence contains the full purpose, scope, and side-effect condition with no filler. Every clause earns its place.

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

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

The tool has no annotations and no output schema, so the description must supply output and invocation context. It explains the primary output and the optional file write, but it does not cover the 'custom' target path, the delivery mechanism of the emitted recipe, or when datasetFile is relevant, leaving some ambiguity.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds meaning for target by naming the supported models and for writeYaml by naming the artifacts/training path, but adds nothing beyond the schema for datasetFile. Baseline 3 is appropriate.

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

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

The description names a specific verb (emit), a concrete resource (LoRA distillation recipe), and the exact model targets (Qwen2.5-0.5B, ModernBERT-421M), plus the optional artifact write. This clearly distinguishes it from sibling jev_* tools such as jev_evaluate or jev_plan.

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

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

No when-to-use guidance or alternative tool comparisons are provided. The description gives target-model context but does not tell an agent when to choose this over related tools or when the optional YAML write should be enabled.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds value by stating the result is 'deterministic' and enumerating the edge-case dimensions (input, concurrency, dependency, auth, state, time, billing), which helps set expectations. However, it does not mention side effects, permissions, external interactions, failure modes, or output format, so an agent still lacks full operational transparency.

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

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

The description is a single, front-loaded sentence with no filler. It states the core action and usefully lists the edge-case categories, making every clause informative without redundant 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?

For a relatively simple two-parameter tool without an output schema, the description covers the main purpose and the domains of edge cases. It is adequate but leaves gaps around the exact output shape, how determinism is guaranteed, and when to prefer sibling tools such as jev_verify or jev_redteam.

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 explains 'spec' and 'count' sufficiently. The description adds little beyond mapping the tool to a 'feature spec', which aligns with the required 'spec' parameter, but it does not deepen parameter semantics such as how 'count' affects the matrix or what constraints the spec should satisfy.

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 ('Generate a deterministic edge-case test matrix') and identifies the resource ('for a feature spec') along with the edge-case categories covered. It is clear and its QA-focused purpose separates it from many siblings, though it does not explicitly name or contrast an alternative sibling.

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 'for a feature spec' gives some contextual guidance about when this tool applies, implying it should be used when QA edge cases are needed for a feature description. However, it provides no explicit exclusions, alternatives, or 'use this instead of X' guidance, leaving the agent to infer the appropriate selection among sibling tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal useful traits: parallel fan-out, no latency/cost increase with extra questions, and the semantics of the three primitives. However, it does not disclose side effects, output shape, error behavior, or whether the operation is safe/read-only, leaving an agent with incomplete behavioral context.

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

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

The description is two tight sentences with no filler. The core action, target, and key constraints are all front-loaded in the first sentence, and the second sentence conveys a relevant performance characteristic. 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 description adequately covers what to send (batch of primitive requests) and the supported kinds, and the rich schema covers parameters well. However, with no output schema and no mention of return values, ordering, batch size limits, or error handling, an agent cannot fully predict the tool's response. For a moderately complex fan-out tool, this is a noticeable gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the kind-specific semantics: 'score (fractional scale)' and 'noul (calibrated probability)' clarify enum values that the schema only lists without explanation. This is genuine added value, justifying a 4.

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

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

The description opens with a specific verb and resource: 'Evaluate a batch of decisions in ONE parallel pass.' It names the three supported primitives (choice, score, noul) with constraints, which makes the tool's function clear. It does not explicitly differentiate from siblings like jev_decide, but the emphasis on 'batch' and 'multi-primitive' provides implicit 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 clearly implies when to use this tool: when you have a batch of decisions to evaluate, since 'Extra questions do not increase latency or cost.' This is a strong contextual signal for batching. However, it does not name alternatives or explicitly state when *not* to use it, 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 behavioral disclosure burden. It does disclose that statuses are honestly reported as implemented or scaffolded, and 'List' implies a read-only operation; however, it does not explicitly state side-effect safety, output format, or any other behavioral caveats.

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 contains the action verb, target resource, count, and the two relevant output dimensions. There is no filler or redundant restating of the tool name.

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-argument listing tool with no output schema, the description gives the essential return content: 20 features, their statuses, and their hosting tool. It could add a note on output format or sibling differentiation, but the core selection and invocation context is present.

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

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

The input schema is empty with zero parameters, so the zero-parameter baseline of 4 applies. The description correctly adds no invented parameter details, leaving no ambiguity about invocation.

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

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

The description names a concrete verb ('List'), a specific resource ('the 20 enterprise features'), and the exact data reported ('implemented/scaffolded status' and 'hosting tool'). This clearly distinguishes it as the feature-catalog tool among the many jev_* siblings.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling tools are named. The title implies it is a catalog, but the description does not tell an agent when to prefer this over tools like jev_audit or jev_backend_info.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses concrete behavior: license classification into permissive/copyleft/unknown and conditional architecture-only extraction with a 5-gram similarity guard. It does not mention side effects or network behavior, but the core behavioral traits are clearly stated.

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 with no filler. It front-loads the main purpose and then adds the conditional extraction behavior, making it both concise and well-ordered.

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

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

For a two-parameter tool with fully documented input schema, the description is nearly complete: it explains the purpose, the conditional behavior, and the output concept. It does not detail output format or failure modes, but the definition is strong enough for an agent to select and invoke 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 coverage is 100%, so the schema already documents repo and similarityThreshold well. The description adds limited extra semantic value by connecting the 5-gram similarity guard to the threshold parameter, but it does not substantially expand on the schema's parameter descriptions.

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

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

The description states a specific, compound action: it audits a repository license and extracts a clean-room spec for restricted licenses. It uses concrete verbs and a unique resource domain ('GitHub', 'license', 'clean-room spec') that clearly separates it from the sibling tools.

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

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

The description implies its use case: audit a repo license and, when the license is restricted, generate a clean-room spec. However, it does not explicitly name alternatives or state when not to use this tool versus jev_audit, jev_research, or other siblings, so the routing guidance is only implicit.

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

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

With no annotations, the description carries the full burden. It discloses that this tool classifies rather than executes the tool call, and it mentions the verdict output and reasons. However, it does not explicitly state that it is read-only, whether it has side effects, or what 'Jev Noul danger' and 'Score severity' mean, leaving some behavioral ambiguity.

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 that immediately states the core purpose and output. It is efficient, though the packed 'Jev Noul danger and Score severity' phrase introduces unexplained jargon that slightly reduces clarity.

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

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

The two required parameters and no output schema mean the description must explain both inputs and return value. It explains the output as a verdict with reasons, which is adequate at a high level, but it does not clarify how to interpret the 'ask' verdict, what reasons look like, or potential error conditions.

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

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

Schema description coverage is 100%, and both parameters ('tool' and 'args') are already described clearly in the schema. The description adds no extra semantics beyond referring to a 'tool call', so it neither improves nor harms parameter understanding beyond 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 states a specific action and resource: 'Classify a tool call before execution' and specifies the exact output ('allow / ask / block verdict with reasons'). It is clearly a pre-execution guardrail, which differentiates it from sibling tools like jev_decide and jev_audit without needing to name them.

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

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

The phrase 'before execution' gives some context on when to invoke it, but there is no explicit guidance on when not to use it or how it compares to alternatives such as jev_pr_gate or jev_redteam. No exclusions or sibling routing are provided.

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

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

With no annotations, the description carries the full burden and does disclose a key side effect: it writes a JSONL file into artifacts/datasets and processes in a 'fan-out pass' (parallel execution). It does not, however, disclose that writeFile defaults to true, what happens when writeFile=false, or whether existing files are overwritten.

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 24-word sentence packs the action, method, output format, destination, and purpose with zero filler. The cost context in the title complements rather than duplicates the description.

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

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

The description covers the core call flow and write destination, and all parameters are schema-documented, so an agent can mostly invoke it correctly. Without an output schema or annotations, key behaviors remain undisclosed: the default writeFile=true side effect, return behavior when writeFile=false, and overwrite semantics.

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 applies; the schema already documents all five parameters. The description adds minor context by framing the enum modes as 'Jev primitives' and naming the exact write destination, but it does not meaningfully extend parameter understanding 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 ('Label'), resource ('raw rows'), method ('Jev primitives'), and output ('JSONL dataset into artifacts/datasets for distillation'), which clearly identifies the tool's function. It does not explicitly contrast with siblings like jev_preference_pairs or jev_evaluate, which also produce datasets, so it stops short of full sibling 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 'for distillation' implies the use case, and the title's '$0/row on local backends' hints at cost as a decision factor. However, the description never explicitly states when to choose this over siblings (e.g., jev_preference_pairs or jev_rerank) or when not to use it.

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

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

With no annotations provided, the description carries the full burden. It does disclose that the tool can both read (inspect, report, state) and mutate (steer, optimize, record) memory, which is useful. But it does not explain side effects of optimize, whether record permanently changes calibration, or what operational guarantees apply.

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, well-structured sentence front-loads the action and resource, then lists the key capabilities in a compact list. There is no filler or redundancy.

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

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

The tool has five parameters, no required parameters, no output schema, and no annotations, which makes it moderately complex. The description does not clarify which parameters are required for op=record, what each op returns, or whether optimize has side effects. An agent could call it with invalid or incomplete parameter combinations and get no guidance from the description.

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 explains each parameter. The description adds high-level context around the op enum (report/optimize/record/state) but does not add meaning beyond what the schema provides.

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

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

The description names a specific resource ('arena-style skill memory') and a pair of clear verbs ('inspect and steer'), then enumerates the concrete capabilities: calibration buckets, verified win rate, threshold auto-tuning, and manual outcome recording. This clearly distinguishes jev_memory from the evaluate/decide/plan siblings by tying it to memory-specific operations.

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: an agent would call this tool when it needs to inspect or modify skill memory. However, it gives no explicit guidance about when to prefer this over sibling tools, no exclusions, and no mention of which memory-related operations belong elsewhere.

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

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

Since no annotations are provided, the description carries the full transparency burden. It does disclose meaningful behavioral traits: it generates a hypothesis/anti-thesis analysis, scores on four dimensions, works offline, and has deterministic fallbacks. Missing are details about side effects, response format, or prerequisites, so transparency is adequate but not comprehensive.

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 purpose and efficiently packs process, scoring dimensions, and offline behavior. Some jargon like 'steeled' and 'hostile anti-thesis' is colorful but not wasteful; overall, every phrase earns its place.

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

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

For a 3-parameter tool with no output schema and no annotations, the description covers the core behavior and constraints reasonably well. It does not clarify output format, how the returned plan is structured, or how this tool relates to siblings in a workflow. Adequate 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 the baseline of 3 applies. The description adds little parameter-specific meaning: it does not elaborate on goal, preset, or context beyond what the schema already states. It introduces no ambiguity or contradiction, but also no added semantic value.

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

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

The description opens with a specific action, 'Produce a steeled plan', clearly identifying the tool as the planning/spec engine. It further distinguishes the tool from siblings like jev_evaluate, jev_decide, and jev_redteam by specifying a unique process and output characteristics: hypothesis, anti-thesis, and scoring on feasibility, failure risk, cost, and maintainability.

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

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

The intended use is implied by the planning verb and title, making it reasonable for an agent to infer when to select this tool. However, there is no explicit guidance about when to use it versus the many sibling tools, and no exclusions or alternative routing are mentioned. The offline/deterministic fallback note gives some environment-related context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it scores and emits JSONL, but does not mention that it may write a file (despite the writeFile parameter), whether the operation is read-only or mutative, or any system interactions. It is silent on side effects and prerequisites, leaving a significant 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?

The description is a single, efficient sentence with no wasted words. It front-loads the primary action and purpose, making it easy to parse quickly. Every word contributes to understanding the tool's function.

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 two parameters and no output schema, the description is insufficient. It fails to clarify whether the JSONL output is returned directly or written to a file, which is critical given the writeFile parameter. It also omits details about the Jev Score primitive's behavior, potential errors, or dependencies. An agent would need additional investigation to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds minimal meaning beyond the schema: it ties 'candidate answers' to the items parameter but does not elaborate on the writeFile parameter or its default behavior. The description's contribution is marginal, staying at the baseline for fully covered schemas.

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 a specific verb ('Score'), a resource ('candidate answers'), and a concrete output ('chosen/rejected JSONL pairs for local DPO training'). It uses the 'Jev Score primitive' to add specificity. However, it does not explicitly differentiate from sibling tools like jev_rerank, which might also involve ranking, but the DPO training context gives it enough 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 implies usage for generating preference pairs for DPO training ('for local DPO training') but provides no explicit when-to-use vs alternatives, no exclusion criteria, and no mention of alternative tools. The context is clear but not directive; an agent would infer the use case rather than receive explicit guidance.

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

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

With no annotations, the description carries the behavioral burden and does so well by framing the operation as a non-mutating 'check' and specifying the allow/ask/block result. It does not mention auth, rate limits, or explicitly state that nothing is modified, but the core behavioral contract is stated directly.

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, front-loaded sentence conveys the action, the input, the specific checks, and the output format. There is no filler or repetition of schema details.

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 provides the essential call contract: what input to supply, what analysis is performed, and the three possible return values. It does not define the exact mapping from findings to allow/ask/block, but those verdict names are largely self-explanatory for a gatekeeper tool.

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

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

The single parameter 'files' is already fully described in the schema with file and patch subproperties, so schema coverage is 100%. The description adds context about what is checked inside the diff, but it does not add field-level semantics 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 names a concrete action ('Check'), a specific resource ('a unified diff'), and enumerates the exact categories it scans for: export removals, hardcoded secrets, console leftovers, TODOs, and dependency manifest changes. It also states the three possible verdicts, making the tool's role unmistakable.

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

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

The intended use is clear: pass a unified diff and receive a gate decision. However, it does not explicitly name sibling tools or state when not to use this tool, so it stops 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?

With no annotations provided, the description carries the behavioral burden. It meaningfully discloses that masking happens locally and prior to external model calls, which is a key privacy-relevant behavior. It does not discuss reversibility, side effects, or the exact output shape, but the local-processing guarantee is strong context.

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

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

One dense sentence front-loads the action ('Mask PII and secrets'), follows with a useful categorized list, and ends with the placement ('locally before...external model'). There is no filler; 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?

For a single-parameter tool, the description is nearly complete: it states what the tool processes, which categories it handles, and when it should be used. The main gap is that the return value is only implied as masked text and is not explicit, with no output schema to compensate.

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

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

Schema coverage is 100% and the only parameter, 'text', is already described as 'Text to sanitize.' The description's list of recognized PII categories adds operational context but does not add parameter-level constraints such as format, length, or encoding expectations.

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 the verb 'Mask' and clearly identifies the resource: PII and secrets, enumerating concrete categories like emails, cards, IBAN, and API keys. It is specific and meaningful, but it does not explicitly contrast itself with sibling tools such as jev_guardrail or jev_redteam, so it stops short of full sibling 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?

'before anything is sent to an external model' gives an explicit triggering context, and 'locally' adds a clear privacy constraint. The description does not name alternatives or state when not to use the tool, but the usage timing is specific enough to guide an agent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the internal workflow: generating anti-theses, scoring severity/evidence, and arbitrating a route with risks and mitigations. However, it does not explain the 'Jev loop' or 'dual loop' behavior, nor what the actual output structure looks like.

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

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

The description is a single dense sentence with no wasted words. It front-loads the primary action and packs the key result into one clause, though the unexplained 'Jev loop' phrase adds minor ambiguity.

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

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

The description gives a reasonable high-level understanding of the tool's workflow and output. However, with no output schema and no annotations, an agent still lacks detail about the exact return format, any side effects, and when this tool is preferable to related siblings.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters, including thesis, context, and maxAntiTheses. The description does not add significant parameter-specific meaning beyond restating the overall adversarial purpose, so the baseline score 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 description clearly states a specific action: generate anti-theses against a thesis, score them, and arbitrate a safest route. This distinguishes it from generic evaluation or decision tools, though it does not explicitly differentiate it from sibling tools by name.

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

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

The description implies the tool is used for adversarial red-teaming of a proposal, but it never states when to use this tool versus alternatives like jev_evaluate, jev_decide, or jev_audit. No explicit conditions or exclusions are provided.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses the key behavior of keeping top-K and discarding noise, which is useful. Still, it omits details like whether the input is modified, whether the output is ordered by relevance, and what happens when fewer than topK documents are supplied.

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 that explains the purpose and outcome with no filler or repetition. Every word contributes meaning.

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

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

For a simple re-ranking tool, the description gives enough context: input passages, a query, and a top-K selection behavior. The lack of an output schema is partially mitigated by 'keep the top-K', which implies the returned ranked subset. Minor gaps around ordering and edge cases prevent a perfect score.

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

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

Schema description coverage is 100%, and every parameter is already documented clearly. The description adds only the top-K and 'noise' framing, which does not substantially enrich the schema-provided parameter 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 uses a specific verb ('Re-rank') with a clear resource ('retrieved passages') and states the concrete outcome ('keep the top-K, dropping the noise'). It is distinct from the sibling tools, which focus on evaluation, planning, and research rather than passage re-ranking.

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

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

The description implies when to use the tool: after retrieval, when you want to filter irrelevant passages and retain only the most relevant ones. However, it does not explicitly state exclusions or contrast itself with any alternative re-ranking tool.

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

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

With no annotations, the description carries the behavioral burden and does disclose meaningful traits: parallel multi-source sweeping, Jev reranking, synthesis of a cited brief, and free/keyless sources by default. It omits operational details like latency or rate limits, but the core non-obvious behaviors are stated.

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 action, source list, processing steps, output, and auth posture. No filler or unnecessary repetition 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?

The main workflow and output ('cited brief') are covered, but there is no output schema and no explicit statement of default channels, what the brief contains, or expected latency. For a three-parameter tool with no annotations, this is adequate but leaves 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 documentation covers 100% of parameters, so the baseline is 3. The description adds little about optional parameters: maxHits is not mentioned, and channels are listed at a high level without clarifying defaults or combination 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?

States a specific action ('Sweep ... channels in parallel'), enumerates concrete sources (Wikipedia/Brave, arXiv, GitHub/npm, HN/X), and names the deliverable ('cited brief'). This scope separates it from siblings like jev_rerank and hub_crawl without ambiguity.

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

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

The description conveys that this is for broad multi-channel research and that no API keys are needed by default, but it never explicitly states when to prefer this tool over siblings or when not to use it. There are no exclusions or alternative routing.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It explicitly reveals two important side effects: persisting a +1/-1 reward to skill memory and auto-tuning gatekeeper thresholds. It does not detail return values or the exact success/failure criteria, but the main behavioral surprises are surfaced.

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, information-dense sentence with the primary action and defaults front-loaded, followed by side effects. It is efficient and contains no filler, though it is slightly dense and could be broken down for easier scanning.

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 main invocation points: working directory, default commands, and reward/threshold side effects. However, it omits how +1 vs -1 is determined, what the tool returns, and what 'auto-tune' concretely changes, leaving meaningful gaps for an agent invoking a stateful tool with no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds useful defaults (cwd, commands) but does not need to add much beyond the schema. It receives the baseline 3 because it enriches defaults without substantially explaining parameter behavior further.

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 ('Run verification commands'), the concrete defaults ('npx tsc --noEmit, npm test'), and the distinctive side effects ('record +1/-1 reward into the skill memory', 'auto-tune the gatekeeper thresholds'). This clearly separates it from siblings like jev_evaluate or jev_guardrail, which don't have this verify-and-reward behavior.

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 context is implied by the title and description: use this when an RLVR-style verification pass is needed and a reward should be recorded. However, there is no explicit guidance on when to prefer this over alternatives like jev_pr_gate or jev_evaluate, and no exclusions or conditions are stated.

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