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

Beyond the readOnlyHint annotation, the description discloses that output is saved to a file whose path is returned, that think=true adds slower reasoning, that fast tier is ~1.4x quicker, and that the tool is unsuitable for correctness-critical tasks. 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 well-structured and front-loaded with the core purpose, followed by scannable Good-for and NOT-for lists. Every sentence adds operational value; no filler or repetition of schema fields.

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

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

Despite having no output schema, the description explains the return value (file path) and covers context limits, performance trade-offs, and selection criteria. It is complete enough for an agent to decide when and how to call this 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?

With 0% schema description coverage, the description compensates by explaining context_files (absolute paths, ~90k chars), model_tier (fast vs strong speed), and think (reasoning/slower). However, timeout_s and max_tokens are not explicitly described, though 'ask for long outputs freely' indirectly hints at output limits.

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: 'Run a self-contained subtask on a LOCAL model and return its text.' This clearly distinguishes it from siblings like search_code and review_diff, and the Good-for list further scopes it.

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

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

The description provides explicit 'Good for' and 'NOT for' sections naming concrete use cases (boilerplate, unit tests, docstrings) and exclusions (final correctness, full-repo reasoning). It also gives operational constraints like ~90k chars context and model_tier trade-offs.

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?

Beyond the idempotentHint annotation, the description reveals the incremental re-embedding behavior, the storage location in the server's data dir rather than the repo, and that search_code auto-refreshes the index. This adds meaningful behavioral context that annotations alone do not convey.

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

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

The description is compact and front-loaded: main purpose first, then incremental behavior, storage, usage positioning, and parameter default. Every sentence contributes information, with no filler or repetition.

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

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

For a moderately complex indexing tool with no output schema, the description covers purpose, incremental semantics, storage side effects, run cadence, and default globs. Missing details such as force semantics and expected return values keep it just shy of fully complete, but the agent has enough to call it correctly in most cases.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains include_globs by noting its default; root and force are left undocumented. Root is somewhat inferable from 'directory tree,' but force's effect is never described, which is a meaningful gap for a 3-parameter tool with zero schema descriptions.

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

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

The description opens with a specific verb-resource pair: 'Build or refresh the LOCAL semantic search index for a directory tree.' It clearly identifies the tool's scope (local indexing) and differentiates it from the sibling search_code by stating that search_code refreshes the index automatically, so an agent can distinguish 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 description gives practical guidance: 'Run once per repo' and notes that search_code refreshes the index automatically afterwards, implying search_code is the tool for queries. It does not explicitly enumerate when not to use the tool or compare against all siblings, but the context is clear enough for confident selection.

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 openWorldHint=false, so the read-only, non-side-effect nature is covered. The description adds valuable context about what is revealed (VRAM placement, competing model) and why it matters. It doesn't describe return format, but for a status tool that's acceptable.

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: first states what it does, second provides when and why. Information is front-loaded and every phrase adds value. No redundancy or fluff.

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 parameterless status tool with no output schema, the description covers everything an agent needs: what it shows, when to call it, and the diagnostic benefit. There are no missing prerequisites or side-effect caveats to document.

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 the schema coverage is 100% (empty schema). Per rubric, baseline is 4. The description appropriately focuses on purpose rather than parameters, which are nonexistent.

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 ('Show') and resource (active local profile, model per tier, Ollama loaded state). It precisely differentiates from sibling tools, which all perform different actions (delegate, review, summarize, index, search). The scope is unambiguous.

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

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

Explicitly states when to use: when a local tool is slow or fails, or before a batch of local work. It explains the diagnostic value (VRAM placement, competing model). This is strong guidance with clear triggers and purpose, even though it doesn't name alternatives, since siblings are distinct tasks.

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 only declare readOnlyHint=true and openWorldHint=false, so the description must carry behavioral context. It discloses that the server may run `git diff` in cwd, that the model is local, that findings are structured with severity levels, and that the output is not authoritative. This is exactly the kind of context an agent needs.

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

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

The description is compact but information-dense, front-loading the purpose, then parameter semantics, then usage caveats. Every sentence contributes, and the examples are positioned where they are most useful.

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 output schema and read-only annotation, the description is complete: an agent knows how to supply input, what defaults apply, what results look like, and how much to trust them. The only undeclared parameters are clearly optional and self-explanatory.

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

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

With 0% schema description coverage, the description compensates well: it explains `diff` vs `git_range`, provides `git_range` examples (`--staged`, `main...HEAD`), documents the `cwd` default, and defines `focus`. However, `think` and `timeout_s` are not explained, so it does not fully cover all six 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 states a specific verb and resource: 'Second-opinion code review of a diff by a LOCAL model; returns structured findings.' This clearly differentiates it from sibling tools like search_code, summarize, and index_codebase. It also names the output format, leaving no ambiguity about 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?

It gives explicit usage context: use as a first pass before or alongside your own review, verify findings against the code, and treat it as 'a cheap second opinion, not a verdict.' It does not explicitly name sibling alternatives or state when not to use it, which keeps it from a 5.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds valuable behavioral context: it refreshes the index first unless refresh=false, returns path:start-end plus a snippet, and uses local embeddings. This goes beyond the annotations and helps the agent predict side effects and output format.

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

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

The description is compact and front-loaded: it opens with the core purpose, gives concrete examples, states the return format, and ends with a clear exclusion. Every sentence earns its place, and the structure makes it easy to scan.

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

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

For a read-only search tool with no output schema, the description covers the main things an agent needs: what to ask, what results look like, the refresh side effect, and when to use a sibling instead. It doesn't detail top_k semantics or root scope, but those are minor given the schema defaults and the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the query parameter via natural-language examples and clarifies the refresh parameter's default behavior. It does not explicitly explain root or top_k, but root is fairly self-evident and top_k has a default; the description's examples and refresh clarification add meaningful value beyond the bare schema.

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

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

The description states a specific verb ('search'), a resource ('codebase'), and a distinctive mechanism ('by MEANING using local embeddings'). It also gives concrete example queries and explicitly contrasts itself with Grep for exact identifiers/strings, which distinguishes it from 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 explicitly says when to use it ('Ask in natural language...') and when NOT to use it ('NOT for exact identifiers or strings — use Grep for those'). It also mentions the refresh behavior and how to disable it, giving clear operational 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?

Annotations already declare readOnlyHint=true, and the description adds meaningful context beyond that: local model execution, map-reduce strategy, megabyte-scale capability, preservation of concrete details, and that the full summary is saved to a file. It doesn't describe failure modes or timeout behavior, but the added operational context is substantial and 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?

Front-loaded with the core purpose and capability, then usage guidance, parameter hints, and a closing exclusion. Dense but every sentence earns its place; slightly long but efficient given the 4 parameters and 0% schema coverage it must compensate for.

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?

Complete for a read-only summarization tool: purpose, when/when-not, parameters, and a behavioral note about saved output. The main gaps are undocumented timeout_s and no explicit statement of what the tool returns directly (no output schema exists), which an agent would need to know. Minor against an otherwise thorough definition.

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

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

With 0% schema description coverage, the description carries the full burden and documents 3 of 4 parameters: paths (absolute), text (inline), and question (with a concrete example). It omits timeout_s entirely, which is a gap, but the parameters it does cover include usage context beyond the schema's bare names.

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

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

States a specific verb ('Summarise') + resource (large files, logs, text) with an explicit mechanism (LOCAL models, map-reduce). Clearly distinguishes from siblings by naming 'Read' as the alternative and scoping to long files, which separates it from search_code, index_codebase, and review_diff. The purpose is unambiguous.

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

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

Explicitly states when to use (long files needing gist or a specific question answer) and when not to use ('NOT for short files (<200 lines): just Read them'), naming the exact alternative tool. Gives a concrete example question. This is as explicit as usage guidance gets.

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