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

With no annotations, the description carries the burden and does add useful behavior: pagination semantics ("paginated with limit/offset") and the notable nuance that unused includes entry points, which prevents misreading results. However it omits whether an index is required, error behavior, or return shape for a 7-parameter analysis tool.

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

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

Two tight sentences: purpose front-loaded, then a dense but scannable kind enumeration, closing with the pagination note. No filler and nothing buried.

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

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

No output schema and no annotations, so the description must fully frame the tool. It covers modes and pagination but leaves output format per kind, index prerequisites (surprising given index_project/check_index_status siblings), and default behavior for optional filters unaddressed.

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 86%, so the schema already documents sort, limit, offset, min_dependents, and the island-size bounds. The description only reinforces the kind enum and the limit/offset pagination pairing, adding little beyond the structured fields. Baseline 3 applies.

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

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

States the resource precisely ("Import-graph analysis") and enumerates all five modes with parenthetical definitions (summary=counts, hotspots=most-imported, circular=cycles, unused=files nothing imports, islands=disconnected groups). This makes each operation concrete, though it never distinguishes itself from the conceptually adjacent sibling get_dependencies.

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 kind definitions imply which mode answers which question, but there is no explicit when-to-use guidance, no statement of prerequisites (e.g., whether an index must exist), and no routing against siblings like get_dependencies or find_references. Usage is inferable but not spelled out.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose the critical trait: this reads status without mutating the index, unlike every sibling. It does not describe the shape of the result, but the core safety/mutation profile is covered.

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

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

Two short sentences, front-loaded with the action and immediately followed by the routing caveat. 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?

For a zero-parameter, no-output-schema status check, the description conveys the operation, its non-mutating nature, and the rarity of use. The only mild gap is that it does not hint at what the report looks like (e.g., boolean vs. list of drifted files), but no output schema exists to defer to.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to add or omit.

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

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

States a specific verb and resource: reports whether the index matches files on disk, and explicitly notes it does so without updating. This clearly separates it from siblings like index_project and the search tools that mutate the index first.

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

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

Gives explicit when/when-not guidance: 'Rarely needed: every other tool updates the index first.' The agent knows this is an exception path and that the default choice among siblings is a search/index tool, not this one.

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 meaningful work: it discloses that only code files are searched, that string/comment matches are filtered by default, and it exposes filtered_out plus pagination fields. It omits any mention of the 'force' safeguard for overly broad patterns, which is a notable behavioral 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 behavior and scope come first, followed by the return shape, so it is well front-loaded. It is dense and reads as a run-on, but nearly every clause carries information an agent needs.

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

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

No output schema exists, and the description compensates by enumerating the answer fields (definition, references, total_references, returned_count, filtered_out, pagination). For a 15-parameter read tool with fully documented schema, the only real gap is the undocumented 'force' safeguard.

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 15 parameters, including include_strings and mode. The description restates those two behaviors (include_strings keeps string/comment matches; mode:'count' returns counts after filtering) without adding syntax or format detail beyond the schema, so the baseline of 3 is appropriate.

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

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

The description names a specific verb+resource ('a symbol's definition and every usage in one call') and scopes it ('in code files only'), which clearly separates it from a generic grep-style sibling like search_code or search_regex. It stops short of naming which sibling to use instead, so it earns a 4 rather than a 5.

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

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

Usage is implied through the default filtering behavior (strings/comments excluded, include_strings overrides) and the count-mode variant, but there is no explicit when-to-use-this-vs-siblings guidance or statement of prerequisites. Adequate but leaves the routing decision to inference.

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

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

No annotations are supplied, so the description carries the full burden and largely fails it. It never states that this is a read-only inspection, whether it touches the filesystem beyond reading, or what the response contains. For a 9-parameter tool with zero annotation coverage this is thin.

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

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

Two compact sentences, front-loaded with the content list followed by the flag behavior. Efficient, though the terse telegraphic style leaves some ambiguity about what each section returns.

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 overview tool with no output schema, the description covers the section flags adequately but leaves path, depth, project_type, return shape, and index prerequisites unexplained. Adequate as a minimum but incomplete for a 9-parameter 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?

With only 22% schema description coverage, the description does add value by mapping the section names to the boolean flags (structure, file_types, framework, entry_points, test_layout, config_files). However it omits project_type entirely and gives no meaning for path or depth, leaving real gaps.

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?

Names the resource (project overview) and enumerates the sections it covers: structure, file types, frameworks, entry points, test layout, config files. Clearly distinguishes itself from search/index siblings, though the verb itself only comes from the tool name rather than the description.

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 only guidance is 'Pass flags to pick sections (default: all).' There is no statement of when to reach for this tool versus analyze, index_project, or check_index_status, and no prerequisites such as whether the project must be indexed first.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the result shape (path, line, classification) and that depth returns a {path, depth} list. It also flags a meaningful constraint, 'Static imports only.' It stops short of any performance or indexing 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 dense sentence cluster with no filler; the core behavior and the reverse alternative are front-loaded. The semicolon stacking is compact but slightly terse, and 'counter' terminology is never defined.

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 read tool with no output schema, the description covers the return fields, the mode parameters, and the static-import limitation. An agent can call it correctly; only cross-tool routing against find_references is left unaddressed.

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 baseline is 3, but the description earns more by explaining both optional parameters' actual effect: reverse inverts the query direction, and depth changes the return type to a {path, depth} list. It also adds that path may be a fragment or file name, useful caller-facing detail.

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 resource ('The imports of a file') and enumerates the returned fields (path, line, internal/external/stdlib), so the agent knows exactly what it retrieves. It does not, however, differentiate itself from sibling find_references, which the reverse:true mode overlaps with.

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

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

It clarifies the two mode-switching parameters ('reverse:true lists the files that import it instead; depth:N follows imports N levels') and notes the 'Static imports only' limitation, which is real usage guidance. It never states when to prefer this over find_references or analyze, leaving cross-tool selection inferred.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: every other tool auto-updates the index before answering, and force triggers a full rebuild for corruption. It omits cost/duration, whether the rebuild blocks concurrent tools, or whether the operation is reversible.

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

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

Two tight sentences, front-loaded with the action and the caveat, with zero filler. The corruption case is placed right where the agent needs 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?

No output schema and only two optional params, so the description need not explain returns. It covers purpose, the normal-case discouragement, and the force semantics; the languages parameter is left entirely to the schema but that is acceptable given 100% coverage.

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 both parameters are already documented ('Full rebuild', 'Only these languages'). The description still adds value by tying force:true to the specific scenario of a corrupted index, which the schema alone does not convey.

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

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

States a specific verb+resource ('Force an index run') and immediately scopes it with 'Rarely needed', which separates it from the search/analysis siblings that read the index. It does not name check_index_status explicitly, so differentiation is implicit rather than explicit.

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

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

Gives a clear when-not-to-use signal ('Rarely needed: every tool updates the index before it answers') and a concrete when-to-use trigger ('force:true rebuilds a corrupted index'). It stops short of naming the alternative tool (check_index_status) for diagnosing index health.

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 and does disclose key traits: unbounded result set ('no limit'), the return shape {path, line}, and preview's trimming to 120 chars. It omits ordering, permissions, and broad-pattern guarding, but covers the main behavioral surprises.

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

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

Three compact clauses, front-loaded with the core question and result shape, then preview behavior, then matching semantics. 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?

For a 12-parameter search tool with a fully documented schema and no output schema, the description supplies what the schema cannot: the result shape and the 'no limit' behavior. It doesn't attempt to summarize the many filter parameters, but the schema handles those.

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 baseline is 3; every parameter including preview is already documented in the schema. The description adds only marginal detail ('trimmed, 120 chars') beyond the schema's own preview text.

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?

Names a specific operation (find every occurrence of a pattern) and its output shape {path, line}. 'The cheapest search, no limit' plus 'Same matching as search_code' gives some sibling differentiation against search_code/search_regex, though the misleading tool name list_locations isn't explicitly reconciled.

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?

Implies usage via 'the cheapest search, no limit', suggesting it's the go-to for exhaustive cheap matching. It references search_code for matching semantics but never states when NOT to use it or which sibling to prefer for regex/AST/reference searches.

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 cost trait: it parses every file selected by lang and glob, hence slow. It implies the glob requirement (with force as the escape hatch, per schema). It does not mention read-only safety or result-return behavior, but the performance disclosure is the important one here.

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

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

Three short sentences, front-loaded with the core purpose and the adversative 'Slow:' constraint immediately after the example. Nothing is wasted and the alternative is the last item.

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 10-parameter tool with no annotations and no output schema, the description covers the operative pitfalls (slowness, glob requirement, alternative tool). Details like pagination via limit/offset and the paths/dependencies toggles are left to the schema, which is acceptable.

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 baseline would be 3, but the description adds real intent for `glob` ('always pass glob') and implies when `force` is relevant. It does not elaborate on the other eight parameters, though the schema documents them fully.

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

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

States a specific verb and resource ('Tree-sitter structural search') and grounds it with a concrete query example `(function_item) @fn`, which immediately conveys the S-expression pattern semantics. It is clearly distinguishable from search_code and search_regex 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?

Explicitly routes the agent elsewhere ('Prefer search_code with symbols:true') and gives a hard usage rule ('always pass glob'), plus the performance rationale behind it. Both when-to-use and when-to-prefer-an-alternative are covered.

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 and does substantial work: it describes the return shape ({columns, rows}), pagination via has_more/offset, and the caveat that total_count is exact only when total_is_exact. It omits any note on cost/performance or broad-pattern refusal beyond the schema's 'force' hint.

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 purpose, then matching modes, then return/pagination behavior, in a dense telegraphic style with no filler. Every clause carries information and suits a tool with 20 parameters.

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 20-parameter search tool with no output schema and no annotations, the description covers matching semantics, result shape, and pagination — the key things an agent needs. It could say more about when broad patterns are rejected and how total_count relates to pagination limits, but nothing critical is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics beyond the schema: whole-identifier matching is the default, contains switches to substring, symbols restricts to definitions, and kind narrows them. It leaves the remaining ~17 filters unexplained, which the schema already covers.

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

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

States a specific verb and resource ('Search code for a literal pattern') and immediately characterizes the output each match carries (path, line, preview). It also distinguishes itself from search_regex by saying 'literal' and from list_locations by naming that sibling as the cheaper path-and-line-only option.

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

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

Gives one explicit routing rule ('for path and line only, list_locations is cheaper') and clarifies the default vs alternative matching modes (contains:true, symbols:true). It doesn't address the other siblings (search_ast, find_references), so it is clear but not fully exhaustive.

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

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

With no annotations, the description carries the full behavioral burden. It discloses useful regex-specific behavior: Rust regex syntax, examples, and JSON backslash escaping. It also says 'Same filters and answer as search_code,' which conveys some result semantics by reference. However, it does not state read-only nature, output format details, or pagination behavior explicitly.

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

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

The description is front-loaded with purpose and stays compact. Each sentence adds value: regex syntax details, escaping instructions, and a reference to search_code for filters and answer shape. It avoids unnecessary length while remaining readable.

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 14 parameters, no annotations, and no output schema, the description is adequate but not fully complete. The schema covers parameter semantics well, and the description handles regex syntax and escaping. However, because there is no output schema, the description's reference to 'answer as search_code' leaves return format details dependent on another tool's 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?

Schema description coverage is 100%, so the schema documents all 14 parameters. The description adds meaningful context for the required pattern parameter by clarifying that it is a Rust regular expression with alternation, classes, and anchors, and by explaining JSON backslash doubling. This goes beyond the schema's vague 'Text to find' for the most important parameter.

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

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

The description states a specific verb and resource: 'Search code with a regular expression (Rust regex).' It also names the regex engine and gives examples. However, it does not explicitly distinguish search_regex from the sibling search_code beyond saying 'Same filters and answer as search_code,' leaving the choice between them to inference.

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

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

There is no explicit when-to-use guidance or comparison with alternatives. The reference to search_code implies similarity but does not say when to use regex search instead of plain code search. No exclusions or prerequisites are provided.

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