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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds a behavioral nuance about using the file parameter to select a definition, which is useful. However, it does not disclose return format, pagination, or handling of multiple definitions. With annotations present, the added value is modest but not negligible.

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 states the core action and the optional file disambiguation. There is zero waste; every word earns its place. It is appropriately concise for a tool of this complexity.

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 4 parameters (one required) and no output schema. The description provides only a high-level purpose and a hint about file selection, but does not explain the required symbol parameter, the limit default, or any edge cases. Given the required parameter is undocumented and the description adds no details, an agent would be under-equipped to call this tool correctly without additional research.

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 50%: file and projectPath have descriptions, while symbol (required) and limit have none. The description does not compensate for the undocumented parameters—it never explains what 'symbol' should be (e.g., a function name, a qualified name) or what 'limit' controls. This leaves the agent guessing about the required parameter, so the description adds no value beyond the schema for these fields.

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 ('Find') and a clear resource ('functions and methods called by a symbol'). It also distinguishes from sibling codegraph_callers by explicitly noting 'called by' rather than 'callers'. The purpose is unambiguous and well-scoped.

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 (you use this to find callees) but provides no explicit when-to-use guidance or alternatives. It does hint at the file parameter's role ('optionally selecting its definition by file'), which gives some context, but there is no mention of sibling tools or when to prefer this over codegraph_callers.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds only the definition-selection nuance and does not disclose what results look like, whether calls are direct or transitive, how results are ordered, or what limit controls — behavior an agent would need to interpret the response correctly.

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 primary action with zero filler, then appends the one conditional behavior that matters (definition selection by file). 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?

For a code-graph query tool with four parameters and no output schema, the one-sentence description is thin. It omits what the tool returns, the meaning of the undocumented limit parameter, and how to disambiguate multiple definitions in practice — gaps that the schema does not fill.

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

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

Schema coverage is 50%; the required 'symbol' and 'limit' parameters lack schema descriptions. The tool description partially compensates by clarifying that symbol is the callee whose callers are sought and that file selects a definition, but it does not clarify the undocumented limit parameter's meaning or bounds.

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?

Clear verb+resource: 'Find functions and methods that call a symbol.' This distinguishes it from the inverse sibling codegraph_callees implicitly (callers vs. callees), though it never names the sibling explicitly. The 'optionally selecting its definition by file' clause adds useful scope precision.

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 a key usage scenario — using file to disambiguate among multiple definitions of a symbol — and the file parameter text routes cross-tool usage ('Use it alone with codegraph_node to read a file'). However, there is no explicit when-to-use/when-not-to-use guidance or named alternatives among the seven siblings.

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 the tool as read-only, idempotent, and non-destructive. The description adds context about the output format (line-numbered source grouped by file) but does not provide additional behavioral details such as limitations or edge cases. Given the annotation coverage, this is acceptable but 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?

Two sentences with no filler. The action is front-loaded, and the usage guidance is concise. 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?

For a read-only exploration tool with three parameters and no output schema, the description gives a basic sense of purpose and output format but lacks clarity on how it differs from sibling tools like search or node. The maxFiles parameter is not explained, and the relationship to other codegraph tools is only implied. This is adequate but has 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?

The description does not mention any parameters. Schema coverage is 67%, which is below the 80% threshold, so the description should compensate for the undocumented maxFiles parameter, but it does not. The projectPath description in the schema is detailed, but the tool description adds no parameter semantics.

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 explores related symbols and line-numbered source grouped by file, which is a specific verb and resource. It also indicates its role as a first tool for broad code questions, but it does not explicitly differentiate from sibling tools like codegraph_search or codegraph_node.

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 explicitly says it is the best first tool for architecture, flows, and broad code questions, giving clear context for when to use it. However, it does not mention any exclusions or alternatives, so it is a 4.

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, idempotentHint, and destructiveHint, covering the safety profile. The description adds one useful behavioral detail: paths are normalized to repo-relative POSIX prefixes. It does not disclose output shape or limits, but the annotation coverage mitigates the need for more safety-related 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 contains exactly two sentences with zero redundancy. The core action is front-loaded, and the second sentence adds a key normalization detail. 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?

Given the tool has six parameters, no output schema, and a nontrivial sibling set, the description is too sparse. It doesn't explain what the tool returns, how format/pattern/maxDepth interact, or any constraints. While the schema describes path and projectPath, the overall context is under-specified for an agent to use the tool fully 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?

The schema documents only 2 of 6 parameters (path and projectPath), leaving format, pattern, maxDepth, and includeMetadata without descriptions (33% coverage). The tool description does not compensate for this gap, only vaguely referencing path normalization. With six parameters and no additional parameter-level explanation, the description provides minimal aid.

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 ('Read') and resource ('indexed project file tree'), making the tool's primary purpose evident. It doesn't explicitly contrast with sibling tools like codegraph_explore or codegraph_search, but the distinctive 'file tree' resource sufficiently differentiates 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 no guidance on when to use this tool versus its siblings. There are no conditions, alternatives, or exclusions mentioned, so an agent must rely on the tool name and schema alone to infer appropriate usage context.

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

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

Annotations already communicate readOnly, idempotent, and non-destructive behavior, so the description does not need to repeat those. It adds useful context about transitive scope and optional file-based definition selection, but it does not disclose depth semantics, traversal direction, or how much of the graph is considered.

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. Every phrase earns its place, and the core purpose is stated before the optional qualifier.

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 analysis tool with no output schema, the description gives the core idea but omits enough detail to confidently invoke it correctly. Missing pieces include clear differentiation from callers/callees, definition of depth behavior, and what the returned impact information looks like.

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

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

Schema descriptions cover file and projectPath, while symbol and depth are undocumented. The description partially compensates by explaining that the file parameter can select a definition for the symbol, but it leaves symbol syntax and depth behavior implicit. This is adequate but not complete.

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 action and resource: 'Analyze the transitive impact radius of a symbol.' It also adds a distinguishing qualifier, 'optionally selecting its definition by file.' However, 'impact radius' is not formally defined, so it could still be confused with codegraph_callers/callees.

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 guidance is given for when to use this tool versus alternatives like codegraph_callers, codegraph_callees, or codegraph_explore. There are no when-not-to-use instructions or exclusions. The file parameter's schema description gives some related context but does not recommend a tool choice.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint), so the description only needs to add behavioral context. It does add meaningful context: file mode returns line numbers and dependents, while symbol mode returns source and relationships. It does not describe output format or edge cases, but it goes beyond what annotations alone 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?

One tightly constructed sentence with two parallel clauses, no filler, and the primary actions front-loaded. It earns its place and is easy for an agent to parse quickly.

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 dual-mode tool with no output schema, the description is thin. It gives mode-level return expectations but omits output shape, relationship depth, and boundaries against sibling tools. The strong annotations and complete parameter schema carry much of the burden, so this is not severely incomplete, but it leaves meaningful 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%, and the parameter descriptions already document file/symbol mode selection, pagination, includeCode, projectPath, and symbolsOnly. The description adds no new parameter-level meaning beyond grouping the two usage modes, 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 states specific actions and resources: 'Read an indexed file with line numbers and dependents' and 'inspect a named symbol with its source and relationships.' It clearly expresses the dual-mode nature of the tool, but it does not explicitly distinguish it from relationship-focused siblings like codegraph_callers or codegraph_callees.

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 mode-level guidance (use file mode to read a file, symbol mode to inspect a symbol), but it never names alternatives or states when not to use this tool. The mention of 'dependents' and 'relationships' could lead an agent to pick this tool over more specific sibling tools such as codegraph_callers or codegraph_impact.

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, idempotentHint, and destructiveHint, covering the safety profile. The description adds behavioral context by stating 'Returns locations only,' which clarifies the output scope and distinguishes this tool from explore. This is useful beyond what annotations provide, though it doesn't detail pagination or other response traits.

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 redundancy. It front-loads the primary purpose and immediately provides the sibling differentiation. Every word earns its place; it is appropriately sized for a search tool.

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

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

Given the tool's simplicity (4 params, no output schema, strong annotations), the description is largely complete. It covers purpose, output scope, and the main alternative. The projectPath nuance is in the schema, and the kind/limit semantics are partially inferable from enums and defaults. The only minor gap is not explicitly describing the behavior of the limit and kind filters, but the description is sufficient for correct invocation 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 50% (query and projectPath have descriptions; kind and limit do not). The description does not explicitly explain kind or limit, and only implicitly maps the 'symbol name' to the query parameter. It fails to compensate for the missing schema descriptions, leaving kind and limit semantics underspecified for the agent.

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

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

The description clearly states the tool's purpose: 'Search indexed declarations by symbol name.' It also specifies the return scope ('Returns locations only') and distinguishes it from the sibling codegraph_explore, making it unambiguous which 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?

The description explicitly provides a when-not-to-use directive: 'use codegraph_explore when you need source and relationships.' This gives clear routing guidance and prevents misuse by naming the alternative and the condition that selects 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that it reports 'health and pending synchronization state', giving some context beyond annotations, but does not describe the output format or any side effects (e.g., whether it triggers a sync). This is adequate given the strong annotations.

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

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

The description is a single, front-loaded sentence that states the tool's function without any filler. Every word earns its place, and it is appropriately sized for a simple status tool.

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 tool with one optional parameter, no output schema, and strong annotations, the description is sufficient. It tells the agent what the tool reports, and the annotations cover behavioral safety. The only minor gap is the lack of detail on what 'health' or 'pending synchronization state' means, but this is not critical for basic usage.

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

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

Schema description coverage is 100%, with the single optional parameter projectPath fully documented. The description adds no parameter-specific information, but the baseline of 3 applies because the schema carries the full semantic load.

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 ('Report') and resource ('CodeGraph index health and pending synchronization state'), making the tool's purpose unambiguous. It clearly distinguishes from siblings like codegraph_search and codegraph_explore, which focus on querying or navigation rather than status.

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 does not explicitly state when to use this tool versus alternatives. The purpose implies it is for checking index status before other operations, but there is no direct guidance on when to prefer it over siblings, nor any exclusions.

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