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 does disclose a real behavioral trait beyond the schema: results are ordered by source line and numbered (#1,#2). It says nothing about resolution behavior, output volume relative to limit, or ambiguity handling.

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 fragments with the core purpose front-loaded and zero filler. The '(#1,#2)' notation is slightly cryptic without further explanation, keeping it from being fully self-explanatory.

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 graph-traversal tool with no output schema and no annotations, the description covers what the tool returns conceptually and its ordering, but omits result shape, what limit does to output, and how unresolved stubs affect results. Adequate but with clear gaps.

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

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

Schema coverage is 67%; 'query' and 'show_unresolved' are documented in the schema, while 'limit' has only a type and default. The description adds no meaning to any of the three parameters, so the partially covered fields remain unclarified.

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 relationship being retrieved: the outgoing calls/awaits of a symbol, explicitly labeled '(outgoing)'. That verb+resource framing implicitly distinguishes it from sibling ccg_callers, though no sibling is named outright.

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

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

There is no explicit when-to-use or when-not guidance. The '(outgoing)' tag hints at the contrast with ccg_callers, but the agent must infer that ccg_callers is the alternative for incoming edges; nothing states prerequisites or that results depend on resolved 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 full burden of behavioral disclosure. It says nothing about return format, ordering, pagination, the meaning of the limit parameter, or how unresolved stubs behave. The only behavioral hint is 'incoming control edges', which is more purpose than behavioral detail.

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-loaded with the core query semantics. There is no wasted text, and the parenthetical clarifies directionality efficiently. It is appropriately sized for the tool's simple interface.

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 three parameters, no annotations, and no output schema, so the description must carry significant context. It states the purpose but omits when to use it versus alternatives, what the result looks like, how limit is applied, and what show_unresolved affects. An agent would need to infer or experiment with the remaining behavior.

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 67%, with the required query parameter and show_unresolved documented but limit undocumented. The description adds no parameter meaning beyond the schema; it merely restates that the query refers to a symbol. It does not compensate for the missing limit 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?

The description states a specific verb and resource: identifying callers/awaits of a symbol via incoming control edges. It clearly distinguishes itself from the sibling ccg_callees tool by specifying directionality. An agent can tell exactly what this tool returns without opening the schema.

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

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

The description implies when to use it (finding incoming edges), but it does not explicitly state alternatives or exclusions. It never mentions sibling tools like ccg_callees or ccg_query, so the agent must infer the contrast. Usage is implied but not guided.

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 implies a read/query operation but never states read-only safety, how the default depth/limit bound results, or what truncated output looks like, leaving behavioral traits largely undisclosed.

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 concise, front-loaded sentence with no filler. Compact, though the trailing analogy is more confusing than informative.

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?

With 5 parameters, no annotations, no output schema, and only 20% schema coverage, an agent lacks enough information to call this correctly. The description should at minimum explain the query semantics and result shaping.

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 only 20% (edge_kind is the sole documented param). The description covers 'in/out' and 'optional BFS depth', roughly mapping to depth, but says nothing about query, limit, or show_unresolved, so it does not compensate for the coverage 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?

It states a graph-neighborhood operation (in/out edges around a symbol with BFS depth), which is a specific verb-ish concept, but the parenthetical 'like codegraph explore for coroutines' is ambiguous and does not cleanly separate it from siblings such as ccg_callers, ccg_path, or coro_explore.

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 statement of when to choose this over ccg_callers, ccg_callees, ccg_path, or coro_explore. The 'like codegraph explore' aside gestures at a use case but gives no selection criteria or exclusion.

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 behavioral burden. It discloses directionality (incoming only), which is genuinely useful, but says nothing about read-only nature, depth/limit behavior, result shape, or truncation — all relevant for a traversal tool with a default depth of 2 and limit of 80.

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 telegraphic fragments with no filler and the key concept ('incoming') front-loaded. But the extreme terseness tips into under-specification — the fragments read as notes rather than a usable instruction, so concision comes at the cost of clarity.

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

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

For a 3-parameter traversal tool with no annotations and no output schema, the description is too thin: an agent cannot infer what depth/limit control, whether results are capped, or what the returned structure 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 description coverage is 0%, so the description must compensate for all three parameters. It partially explains the query forms (bare symbol, file:…, *.h glob), but depth and limit are never mentioned, and the file:… syntax is left cryptic.

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 operation — incoming dependency/impact analysis — and maps the two input kinds to their results (symbols → callers, files → importers via #include). That is enough to distinguish it from an outgoing tool, but it never names or differentiates itself from the sibling ccg_callers, which appears to overlap.

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 'Symbols: … Files: …' fragments implicitly tell the agent which query form yields which result, which is real usage guidance. However, there is no statement of when to prefer this over ccg_callers, ccg_callees, or ccg_explore, and no prerequisites or exclusions.

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, but it does disclose the return content: location plus which edge types are produced per node kind (callers/callees for symbols; contains/includes/importers for files). What's missing is whether this is read-only, whether edges are directional, and any limits on how many edges are returned.

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 with no filler, front-loading the core output then the per-type edge breakdown. Efficient, though the telegraphic style borders on under-specification.

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 graph-lookup tool with no output schema and ten siblings, the description does not explain invocation (query syntax, direction/semantics of returned edges) or when this beats ccg_callers/ccg_callees. It gives partial return-value context but leaves key operational questions unanswered.

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 67%, and the description mentions none of the three parameters. The 'query' parameter's meaning (symbol keyword or qualified_name fragment) and 'show_unresolved' are only explained in the schema, so the description adds no parameter value and does not compensate for the coverage 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?

The description conveys that the tool returns a single node's location plus related edges, and it distinguishes between symbol and file node types. However, there is no explicit verb ('get/retrieve') and the cryptic name 'ccg_node' needs the description to carry full meaning. It differentiates symbol vs. file behavior, which helps against siblings.

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

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

There is no guidance on when to use this tool versus alternatives like ccg_callers, ccg_callees, or ccg_explore. The description implies it covers both caller/callee edges and file containment, but doesn't say when a direct node lookup is preferred over those specialized 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?

No annotations are provided, so the description carries the full burden. It does not disclose whether the operation is read-only, whether results are deterministic, how depth/limit affect output, or any error conditions. Only a minimal hint about include topology is given.

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

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

A single, front-loaded sentence with no filler. Efficient, though it could be slightly more structured to separate the control-vs-include modes.

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-parameter graph query tool with no annotations, no output schema, and incomplete parameter descriptions, the definition is insufficient. It doesn't explain return values, depth/limit behavior, or when the tool is appropriate versus siblings.

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

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

Schema coverage is 0% and the description only hints that 'src' and 'dst' can take file:path or *.hpp forms. It does not explain what 'depth' or 'limit' mean or how they constrain the path search, leaving half the parameters 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: 'shortest path between two symbols (control) or two files (includes)', making the operation clear. It distinguishes itself from siblings like ccg_query or ccg_node by naming the graph-traversal semantics, though it doesn't explicitly reference 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?

Provides a usage hint ('Use file:path or *.hpp queries for include topology') that indicates a query syntax context, but does not state when to prefer this tool over alternatives like ccg_callers or ccg_explore, nor any prerequisites.

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 behavioral burden. It never states this is a read-only lookup, says nothing about the default limit of 30 or result truncation/pagination, and does not describe result shape; only the empty-query-plus-namespace listing behavior is disclosed.

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

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

Three compact clauses with the core purpose front-loaded and no filler. The final claim about an empty query plus namespace listing 'that module' is slightly terse, but overall it is tightly written.

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 search tool with no annotations and no output schema, the description covers querying and filtering adequately. It is silent on the default limit, result caps, and ordering, which an agent needs to use the tool predictably.

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 80%, so the schema already documents kind, query, namespace, and path_prefix. The description reinforces kind=file and the exact/nested namespace semantics but adds no format detail beyond the schema, which merits the baseline 3.

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 (search) and resource (symbols or file nodes) plus the matching basis (name/qname/path fragment). Clear on its own, but it never distinguishes itself from sibling graph tools like ccg_node, ccg_explore, or ccg_path.

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 useful conditional guidance ('Use kind=file for files', 'Empty query + namespace lists that module'), which implies how to drive it. It stops short of saying when to pick this over ccg_node or ccg_explore, so usage is inferred 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 burden, and it does disclose the key behavioral trait: results are ordered by source line, and it is a preferred alternative to explore. However, it says nothing about return shape, how limit truncates the sequence, or what unresolved stubs imply.

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 with zero waste; the core capability is front-loaded ahead of the routing hint. Nothing redundant.

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 mean the description should carry more of the load. It conveys what the sequence is and its ordering, but omits result shape, limit semantics, and how unresolved entries appear, leaving the agent to infer these.

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 67% (query and show_unresolved are documented, limit is not). The description implies query identifies a function symbol, which adds a little meaning, but it does not clarify limit or show_unresolved behavior. Baseline 3 is appropriate where the schema does most of the work.

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 resource and scope: the ordered call/await sequence inside a single function, ordered by source line. It also explicitly distinguishes itself from the sibling ccg_explore path (edge_kind=seq), so an agent can choose without opening schemas.

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 positive condition ('understanding in-function order') and names the alternative it supersedes (explore edge_kind=seq). It does not state when this tool is the wrong choice (e.g., cross-function or interprocedural ordering), leaving a small gap.

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 one useful trait: it should be called first as a DB-loaded health check, implying failures when the graph is absent. It does not describe what happens on an unloaded DB, cost/latency, or the response shape.

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, front-loaded sentences with no padding: what it counts, the optional grouping mode, and the call-first advice. The "cpp-coro-graph:" prefix is slightly redundant but sets domain context cheaply.

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-required-parameter stats tool with no output schema and no annotations, the description covers the core use and the call-first check. It is still thin on limit semantics and failure behavior, which matter given the absence of structured hints.

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 67%; by_namespace and namespace are already documented in the schema, and the description largely restates by_namespace's meaning. The limit parameter has no description in either place, so the description does not compensate for the coverage 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 concrete verb and resource: node/edge counts broken down by kind and device, plus an optional per-namespace mode. It is distinguishable from query/node/callers siblings, but it never clarifies how it differs from the very similar sibling coro_stats.

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 first to confirm the graph DB is loaded" gives explicit ordering guidance that an agent can act on. However, no condition is given for choosing ccg_stats over coro_stats, so the routing guidance is incomplete.

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 responsibility for behavioral disclosure, but it reveals nothing about side effects, permissions, rate limits, or return behavior. 'Legacy' is the only trait mentioned and it is not behavioral.

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 single sentence is concise and front-loaded, but for a tool with four parameters and no other documentation, this level of brevity is under-specification rather than effective conciseness. It does not earn its place as sufficient guidance.

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 four parameters, no annotations, no output schema, and numerous sibling tools, the description is far too sparse. It does not explain the tool's operation, parameter usage, or how it relates to the sibling ccg_explore beyond a bare alias statement.

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

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

The input schema has 4 parameters with 0% description coverage, and the description does not mention any of them (query, depth, limit, device). It offers no meaning, format, or constraints beyond what the bare schema shows.

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 only states that this tool is an alias of ccg_explore (legacy). It does not provide a verb or resource to explain what the tool actually does, so an agent cannot understand its purpose without already knowing ccg_explore.

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 word 'legacy' hints that this tool is deprecated and that ccg_explore may be preferred, but there is no explicit instruction on when to use this tool versus ccg_explore or other siblings. No usage conditions or exclusions are given.

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 behavioral burden. It discloses nothing about safety, permissions, side effects, return format, or operational limits. 'Alias of ccg_stats' is a pointer with zero behavioral detail.

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 sentence with no filler, and the alias relationship is front-loaded. There is no wasted text or buried detail.

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

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

The tool has no parameters, no output schema, and no annotations, so the description could be complete with very little. However, it only references ccg_stats and provides no self-contained purpose or behavior. An agent must consult another tool's definition to use this one meaningfully.

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 there are no parameter semantics to explain. The schema is empty and no additional parameter meaning is needed. Baseline of 4 applies for a zero-parameter tool.

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 only states that the tool is an alias, without naming the verb or resource it operates on. It does point to the sibling ccg_stats, which lets an agent infer equivalence, but the actual purpose (what stats are computed) is left entirely to the sibling. This is more than a tautology but still vague on its own.

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 guidance on when to call coro_stats versus ccg_stats or any other sibling. The word 'alias' implies interchangeability, but the description does not state conditions, prerequisites, or exclusions. An agent gets no routing help beyond the bare equivalence.

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