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

With no annotations, the description carries the full burden, but it does add real behavioral context: results are "source-backed" and return "IDs and spans, never arbitrary files," which tells the agent the result shape and constraints. It omits read-only nature, pagination, and any failure/empty-result behavior for a 6-param tool.

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

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

Two tight sentences, front-loaded with the core action and followed by the return-value constraint. No wasted words, though the extreme brevity is part of why parameter detail is missing.

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 6-parameter tool with no annotations, no output schema, and 0% schema description coverage, the definition is under-specified. It states return contents but leaves parameter meaning and usage boundaries to inference.

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 — but it only hints at the pattern parameter. kind, profile, limit, max_tokens, and repo_id are undocumented anywhere, leaving half the parameter surface opaque (e.g., what kind values are valid, what profile selects).

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?

"Find source-backed symbols by name or qualified-name pattern" gives a specific verb (find) and resource (symbols) plus the lookup key. It clearly distinguishes a symbol search from file-level siblings like search_source, though it never names an alternative explicitly.

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

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

The description implies when the tool is useful (name/qualified-name lookup) but offers no explicit when-to-use, when-not-to-use, or routing guidance among the many symbol-related siblings (inspect_symbol, get_symbol_context, search_source). An agent must infer the boundary itself.

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 usefully discloses that function bodies are elided by default, which is a meaningful behavioral trait, but says nothing about permissions, whether the operation is read-only, truncation behavior from max_tokens, or what the profile parameter alters.

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 with no filler, and the core output (imports and headers) is front-loaded. The phrasing 'Imports and source-backed headers' is slightly awkward but compact.

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 5-parameter tool with no annotations, no output schema, and 0% schema description coverage, this description is far too thin. It omits parameter meanings, privacy behavior, truncation behavior, and any sense of output shape beyond the elision default.

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% across 5 parameters, so the description must compensate but largely does not. 'One file' weakly implies path/repo_id, and 'by default' weakly hints at profile or include_private configurability, but max_tokens, include_private, and the profile semantics remain entirely undocumented.

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 the specific resource (one file) and what is returned (imports and source-backed headers), and distinguishes the resource from siblings like search_source or inspect_symbol by naming the skeleton concept. It is clear but does not explicitly differentiate itself from the sibling set.

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 guidance on when to use this tool versus alternatives such as inspect_symbol, get_symbol_context, or search_source. The agent must infer that a file skeleton is preferred over symbol-level or source-text tools, which is not stated.

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 full behavioral burden. It usefully discloses that edges are 'observed' and the result is a 'candidate impact slice, not complete blast radius,' but omits permissions, return behavior, and limits for its 9 parameters.

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

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

Two short, front-loaded sentences with no wasted words. The scope caveat is placed immediately after the core action, making the description 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 tool with 9 parameters, no output schema, and no annotations, the description is too thin. It gives the core purpose and a scope caveat but leaves parameter behavior and invocation guidance almost entirely undocumented.

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% for 9 parameters, and the description adds no meaning beyond 'from a symbol' and 'caller/callee edges.' It does not explain depth, profile, max_nodes, max_tokens, min_confidence, or filter_ambiguous.

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: traverse observed caller/callee edges from a symbol. The added caveat 'Candidate impact slice, not complete blast radius' clarifies scope, though it does not name sibling alternatives like get_module_dependents.

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 explicit when-to-use guidance or alternatives are provided. The caveat 'not complete blast radius' hints at a limitation but does not route the agent to another tool or condition.

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 the timing guidance and that it reports index freshness/changed paths, but it does not explicitly state read-only safety, side effects, permissions, or freshness semantics, leaving behavioral traits partly implicit.

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 with no filler and usage guidance front-loaded after the return summary. The first sentence is a fragment, but the description avoids bloat.

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

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

Given no annotations, no output schema, and no parameter descriptions, the description is under-informative: it covers return content at a high level but omits repo_id semantics and safety/profile details. It is not complete enough for an agent to call without additional assumptions.

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 0%, so the description must define repo_id, but it never mentions the parameter. The single required parameter's meaning, format, and scope are left to inference from its name alone.

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 supplies the data returned (active snapshot metadata, changed paths since indexing) but never uses a clear verb and does not differentiate this status check from the graph-query siblings. An agent can infer it is a read, but the purpose is not stated as explicitly as a 'returns X' statement would be.

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 a clear trigger: run before relying on graph results. No when-not condition or alternative tool is named, so it stops short of 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?

With no annotations, the description carries the full burden and does disclose meaningful caveats: results are lexical rather than semantic, and dynamic imports are flagged separately. However, it never clarifies directionality (do dependents mean files that import this module, or its imports?), nor result format, limits, or indexing requirements.

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 fragments, front-loaded with the core purpose and the caveat, with no filler. It is telegraphic to the point of strain but every clause carries information.

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

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

For a 5-parameter tool with no schema descriptions, no annotations, and no output schema, the description leaves too much unaddressed: required repo_id, profile, max_tokens, and the direction of the relationship. An agent could not invoke this reliably without guessing.

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% across 5 parameters and the description only addresses two of them (path, module). repo_id is required yet unexplained, and profile and max_tokens are never mentioned, so the description does not compensate for the schema gap.

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 (lexical import relationships) and scopes it to an indexed path or module, which is enough to tell it apart from siblings like get_repo_map or find_symbols. The verb is implicit ('get' in the name), but the returned concept is clearly identified.

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 when-to-use guidance, no prerequisites, and no reference to sibling alternatives such as get_impact_slice or get_symbol_context. The phrase 'for indexed path or module' hints at applicability but does not guide tool 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?

No annotations exist, so the description carries the full burden. It usefully discloses the entry format, the budget constraint ('within budget'), and a coverage caveat, but says nothing about auth, performance, or how budget truncation interacts with include_omitted_ids.

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 dense sentences, front-loaded with the core purpose and output contract, with the caveat last. 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 7-parameter tool with no annotations and no output schema, leaving four parameters unexplained and omitting any routing guidance to the many sibling discovery tools is a substantial gap, even though the format and coverage caveat are handled well.

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 0% with 7 parameters. Only format='full' vs compact is explained and budget_tokens is hinted at via 'within budget'. query, profile, include_tests, and include_omitted_ids are entirely undocumented in both schema and description.

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

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

States a concrete verb+resource ('Ranked definitions for a repo_id') and the two output shapes, which distinguishes it from siblings like get_file_skeleton and get_symbol_context. It does not explicitly name the sibling it complements, so it stops short of a 5.

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

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

'For orientation, not proof of full coverage' implies when the tool is appropriate, but there is no explicit when-to-use versus alternatives such as get_file_skeleton or inspect_symbol. Usage is suggested rather than stated.

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 usefully discloses that the result is bounded and that large bodies are read in windows via max_tokens and body_offset_line, but it omits permissions, error behavior, and freshness/ambiguity warning semantics.

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 short and front-loads the core purpose, then adds two relevant behavioral notes. It avoids repetition, though the wording is terse enough that some important details feel compressed rather than clarified.

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

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

For an 8-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description is materially incomplete. It covers the surface purpose and windowing behavior but leaves most parameters, return structure, and alternative-tool selection unexplained.

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% and there are 8 parameters, so the description must compensate. It explains only max_tokens and body_offset_line indirectly; depth, profile, include_body, include_omitted_ids, repo_id, and symbol_id remain undocumented beyond their titles.

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 identifies a specific resource: a bounded source packet for an indexed symbol plus observed edges. It communicates what the tool returns, but it does not distinguish the tool from siblings such as inspect_symbol or get_file_skeleton, so an agent must infer the boundary.

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 output-related advice ('Check freshness and ambiguity warnings') but does not state when to choose this tool over alternatives like inspect_symbol or find_symbols. No prerequisites, exclusions, or selection criteria 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?

No annotations are provided, so the description carries the full burden. It doesn't state whether this is read-only, whether there are rate limits or caching behavior, what 'immediate graph' means in practice, or how the view modes affect behavior. The token budget implication is only hinted at.

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 tight sentences, front-loaded with purpose. No wasted words, though the 'view=full' detail would be better placed after establishing the baseline behavior.

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 4-param composite tool with no annotations and no output schema, the description is thin. It doesn't explain the return packet shape beyond a partial list, doesn't document the budget_tokens interaction, and leaves view semantics mostly opaque.

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 0%, so the description must compensate for undocumented params. It mentions view='full' but doesn't explain what 'minimal' or 'normal' return, doesn't clarify the required 'query' semantics (symbol name? pattern?), and never mentions repo_id or budget_tokens.

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: 'Resolve a symbol and its immediate graph in one call.' Clear on what the tool does, though it doesn't distinguish itself from sibling get_symbol_context, which likely overlaps significantly.

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?

Says 'Use before editing a symbol,' which implies a workflow context. But it gives no explicit when-not-to-use guidance and doesn't differentiate from close siblings like get_symbol_context or find_symbols.

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 burden. It adds one useful behavioral fact ('roots are never exposed'), which tells the agent something about result scoping. However it omits return volume, ordering, and whether an index must exist, leaving the safety/behavioral profile thin for a tool with zero annotation coverage.

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

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

Two short sentences, purpose front-loaded, followed by the usage cue and the scoping note. Every clause earns its place with 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?

A zero-param read tool with no output schema is largely self-describing; the description names what is returned (IDs) and a scope caveat. It could have mentioned whether an index must be built first, but nothing essential to invoking it 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify beyond confirming it is a no-argument listing call.

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 ('List registered repository IDs') and even specifies the return granularity (IDs, not full repo objects). It doesn't explicitly differentiate from siblings like get_repo_map or get_index_status, but the resource is distinct enough that confusion is unlikely.

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

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

'Call this first' gives a clear ordering cue for the workflow, which is meaningful for a discovery tool. It does not name an alternative or a when-not condition, so it falls short of a full 5.

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

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

With no annotations, the description carries the full burden, and it does disclose two real behaviors: symbol-based ranking and graph expansion that adds resolved callers/callees as neighbors. It says nothing about permissions, cost/latency, ranking fallback, or what happens with the non-enum parameters, so transparency is partial.

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, then the expand behavior, then a usage cue. No padding, though the parameter detail sentence is dense and cryptic without surrounding context.

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?

A 9-parameter tool with no annotations, no output schema, and 0% schema description coverage needs considerably more from the description. It explains only one parameter interaction and omits the meaning, defaults, and effects of most arguments, leaving an agent under-equipped to invoke 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 0% and there are 9 parameters, so the description must compensate. It only clarifies expand='graph' and its interaction with profile 'locate', leaving limit, max_tokens, expand_k, expand_hops, and min_confidence completely undocumented in both schema and description.

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

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

States a specific verb+resource ("Full-text search") and adds a distinguishing behavioral detail: results are ranked by enclosing symbol. It does not, however, differentiate itself from siblings like find_symbols or inspect_symbol, so an agent cannot tell from the text alone which search tool to pick.

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

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

"Call before reading files" gives an implied usage context, suggesting this is a discovery/entry-point tool. But there is no when-not guidance and no explicit routing to alternatives such as find_symbols for symbol lookups, so the guidance stays at implication level.

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