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

With no annotations provided, the description carries the full burden; it does disclose the main transformation and output categories: combine waveform, hierarchy, and source information, and return recommended instances, signals, and source files. It does not elaborate on side effects, failure behavior, or dependencies beyond the implicit 'normalized failure_event' prerequisite, but the core behavior is not hidden.

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 or repetition. It efficiently states the starting input, the data sources combined, and the output types, which is good for conciseness even if the tool's complexity might warrant more 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?

For a tool with 6 parameters, nested objects, no output schema, and no annotations, the description is too thin to fully guide correct invocation. It omits the explicit relationship to parse_sim_log, the role of optional parameters, and any guidance on what the recommended output looks like structurally.

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 only 33%, and the description compensates only loosely: 'waveform, hierarchy, and source information' hints at wave_path, top_hint, and compile_log but never maps these terms to actual parameters. It does not clarify log_path, top_hint, or compile_log semantics, and the only meaningful parameter explanation comes from the schema's failure_event 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 clearly identifies the tool's action: start from a single normalized failure_event, combine waveform/hierarchy/source information, and return recommended instances, signals, and source files. It distinguishes itself from plural/multi-event siblings like analyze_failures by emphasizing 'single normalized failure_event', though it does not explicitly name an alternative tool.

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 phrase 'Start from a single normalized failure_event' implies the tool is meant to be used after parse_sim_log and per single failure event, giving some usage context. However, it does not explicitly say when to prefer this tool over siblings such as analyze_failures, recommend_failure_debug_next_steps, or get_diagnostic_snapshot, nor does it state 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 provided, the description carries the full behavioral disclosure burden. It usefully discloses that only the first occurrence of a single failure group is examined, that it returns specific artifacts, and that FSDB support depends on fsdb_runtime.enabled. This gives an agent meaningful context beyond the tool name and schema.

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 filler and front-loads the core purpose. The key scoping detail (first occurrence, single failure group) appears early, and the FSDB dependency is included as a necessary operational caveat.

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 description states what outputs to expect, which is important because there is no output schema. It also covers a critical runtime dependency. It could be stronger by explaining how this tool relates to sibling analysis tools, but for a single-tool invocation it is reasonably complete.

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 100% parameter coverage, so the schema already documents each parameter. The description does not add extra semantic detail about parameters, but it is not required to compensate for missing schema descriptions. Baseline 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 clearly identifies a specific failure-analysis tool and states its scope: the first occurrence of a single failure group. It also lists concrete outputs (log summary, raw error context, waveform snapshot), making the tool's purpose easy to grasp. It does not explicitly name or distinguish sibling tools, 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?

The text says this is the "core failure-analysis tool," which suggests general use, but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as analyze_failure_event or recommend_failure_debug_next_steps, nor does it explain how to choose among the many sibling tools.

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 covers a lot: cache location, cache-hit reuse, LSF queue behavior with no fallback, generation of build.sh, and the VERDI_HOME requirement. It does not mention error behavior or the exact return value, but for a build/caching tool the key side effects and preconditions are 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?

The description is dense but every sentence earns its place: purpose, when to use, caching behavior, LSF execution semantics, reproducibility script, and environment prerequisite. The most important information is front-loaded in the first two sentences, making it easy for an agent to quickly decide whether to invoke the 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 mutation/build tool with no annotations and no output schema, the description does strong work by covering environment requirements, caching, LSF behavior, and side effects. It stops short of stating what the tool returns on success or failure, which would make it fully self-contained for an agent. Overall, the missing return/error contract is a minor but real gap.

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 baseline is 3. The description reinforces the meaning of force_rebuild ('force-refresh') and compile_log ('parsed compile log'), but it does not add substantial parameter-level detail beyond what the schema already provides. It adds context around environment variables and execution mode rather than 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 first sentence states a specific action and resource: 'Auto-build a Verdi KDB from a parsed compile log using vericom + elabcom.' It immediately differentiates this tool from the analysis/query siblings by focusing on construction of a KDB cache artifact. The use cases (Xcelium, missing KDB, stale cache) further disambiguate its purpose.

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

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

The description explicitly says when to use the tool: when the simulator is Xcelium (xrun), the NPI backend reports no KDB, or a stale cached KDB needs refreshing. It also gives behavior-specific guidance for TRACEWEAVE_NPI_EXECUTION=lsf. It does not explicitly name a non-use case or contrast with a sibling alternative, but the 'use this when' phrasing is clear enough.

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 to supply safety or behavior hints, the description carries the full burden and does so well. It discloses caching, non-retention of raw source bodies, SLIM payload behavior, timeout/source-byte guard blocking, and the need to use the handle with getter tools.

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 the core action and key behavior, then expands into usage guidance, return payload summary, and blocker behavior. Each sentence earns its place without redundant 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?

Since there is no output schema, the description compensates by summarizing the SLIM payload fields and the blocked response. It also covers input guidance, server-side caching, privacy-relevant behavior, and subsequent tool usage, making it complete for an agent to call 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining which log should be compile_log in split VCS flows and that supplementary logs participate in hierarchy identity via their order.

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 action: stream logs, scan source files, and cache the testbench hierarchy server-side. It clearly distinguishes this tool from the sibling getter tools by framing it as the builder that returns a hierarchy_handle for later access.

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 clear context for use, including how to choose compile_log in split VCS flows and how to order supplementary logs. It also names the follow-up tools that consume the handle, but it does not explicitly state when not to use this tool versus alternatives.

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 explicitly states that the tool returns whether the cursor existed, which indicates that deleting a non-existent cursor is handled gracefully rather than raising an error. The destructive nature of the operation is clear from the verb 'Delete', and no contradictory or hidden behavior is suggested.

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 concise sentence that front-loads the core action and includes the key return behavior. There is no filler, redundancy, or unnecessary 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?

This is a one-parameter tool with no output schema. The description, combined with the schema, covers the action, the target parameter, and the return behavior. An agent has all the information needed to invoke the tool correctly.

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

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

Schema description coverage is 100%, with the single 'name' parameter already described as 'Cursor name to delete.' The description adds no additional parameter-level semantics beyond what the schema provides, so the baseline score 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 uses a specific verb ('Delete') and identifies the resource ('named cursor'), making the tool's purpose unambiguous. It is clearly distinct from sibling tools like cursor_set and cursor_list, which handle creation and listing respectively.

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 no guidance on when to use this tool versus alternatives. There are no mentions of prerequisites, context, or exclusions, and it does not reference related sibling tools. The intended usage is only implied by the action verb 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?

No annotations are provided, so the description carries the full burden. It discloses the ordering behavior and session scope, which is useful. However, it does not mention whether any state is modified, what happens when no cursors exist, or what the return format is. For a simple list tool 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?

The entire description is a single, front-loaded sentence with no filler. Every word adds meaning: scope ('current session'), operation ('list'), and ordering ('by time'). It is a model of concise documentation.

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 tool with no output schema, the description provides the essential information: what it lists, the scope, and the ordering. It could mention the expected return shape (e.g., array of cursor IDs), but that is largely inferred from the tool name and description. Overall, an agent can invoke this correctly without further details.

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 accepts zero parameters, so there is nothing to explain. Per the rubric, a zero-parameter tool gets a baseline of 4, and the description correctly implies no inputs are required. There is no parameter ambiguity to resolve.

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 ('List') with a clear resource ('all cursors registered in the current session') and adds ordering ('by time'). This clearly differentiates it from the sibling tools cursor_set and cursor_delete, which are about modifying cursors.

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 clearly indicates that this tool is for inspecting cursors within the current session, which implies when to use it. It does not explicitly exclude alternates, but the sibling names (cursor_set, cursor_delete) make the intended context obvious. A small gap is the lack of explicit 'use this when you need to review active cursors' guidance.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It usefully states that cursors are process-scoped and dropped on server restart, and it provides the name regex. However, it does not mention what happens when re-registering an existing name (overwrite vs error), which is a meaningful 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 description is three sentences long with no filler. The core purpose is front-loaded, followed by usage context and validation rules. Every sentence earns its place and provides necessary 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 simple registration tool with only two required parameters, the description covers purpose, usage, lifetime, and naming constraints. Missing details like overwrite behavior and return payload are not critical to invoking the tool. No output schema is present, so those details would be a nice-to-have rather than a blocker.

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 already describes all parameters with 100% coverage, so the baseline is 3. The description adds value by specifying the name pattern regex and explaining that time anchors can be referenced as '@<name>', which goes beyond the schema. This additional guidance helps an agent use the parameters correctly.

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 action ('register') and the resource ('named time anchor'), making it easy to understand what the tool does. It also indicates how the anchor is used by other tools ('@<name>'), which distinguishes it from cursor_list and cursor_delete. No ambiguity remains about the tool's core purpose.

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 clear context for when to use this tool: to create reusable named time anchors and avoid copying ps integers. It also gives practical constraints such as process-scoped lifetime and naming rules. It does not explicitly discuss exclusions relative to cursor_list/cursor_delete, but the purpose is clear enough for an agent to select it appropriately.

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 provided, the description carries the full burden of behavioral disclosure. It explicitly discloses the side effect (auto-registering a cursor for downstream reference) and the read-only nature ('Reads existing waveforms only — does NOT rerun simulation'). It doesn't mention edge-case behavior like 'no divergence found,' but the key behavioral traits are 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?

Three sentences with no wasted words. The first sentence states the core function, the second gives use-case context, and the third addresses side effects and safety. All information is front-loaded and 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?

The description covers the main behavior, use cases, and side effects, but since there is no output schema, the return value is not explicitly described. The agent can infer it likely returns a divergence time and/or cursor name, but the ambiguity around what happens when no divergence is found and what exact data is returned leaves a meaningful gap for a tool of this complexity.

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 parameter semantics baseline is 3 even without additional explanation in the description. The description itself does not add parameter-level meaning, but the schema already documents all eight parameters, including formats for time values and cursor references.

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

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

The description opens with a specific, unambiguous action: 'Find the first time two signals hold unequal values.' It then distinguishes two concrete use cases (across two waveforms, or within one waveform), which clearly separates it from sibling tools like get_signal_at_time or get_signal_transitions that inspect signals without diffing.

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 clear context for when to use the tool, identifying both the cross-run and within-run comparison scenarios. It does not explicitly name alternatives or state when not to use it, but the two use-case patterns give the agent enough situational guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses the comparison's output dimensions and the important dependency on parse_sim_log snapshot timing. It does not explicitly state read-only/no side effects, but the described behavior is otherwise transparent for a comparison utility.

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 sentences, front-loaded with the core purpose and return categories, followed by a compact caveat. There is no filler, no repetition of schema field names, and every sentence 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 tool with no output schema and no annotations, the description covers the returned information, parameter selection, and a critical workflow edge case. The only notable gap is not telling an agent when to choose this over diff_first_divergence, and not describing the exact output format.

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 baseline is 3. The description adds value beyond the schema by explaining the workflow relationship between new_log_path and parse_sim_log snapshots, and clarifying when snapshot IDs can substitute for paths. This is meaningful 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 opens with a specific verb and resource: 'Compare normalized failure events from two simulation logs.' It then enumerates what is returned (resolved, persistent, newly introduced failures, changes in failure type, X/Z presence, first-failure timing, convergence summary), which clearly differentiates it from siblings like parse_sim_log and diff_first_divergence.

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 concrete procedural guidance for the tricky same-path overwrite case: pass new_log_path only after parse_sim_log has captured the baseline snapshot, or pass snapshot IDs. It does not explicitly name alternatives or state when not to use this tool, 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 of behavioral disclosure. It honestly reveals that this is an escape hatch returning 'raw' data and is 'intentionally heavy,' which warns about performance and lack of refinement. It does not fully describe output shape or potential errors, but for a read-oriented dump tool it provides the key behavioral 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 is two short sentences with no filler. The key warning and purpose are front-loaded, and the usage guidance is tightly integrated without redundancy.

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 lack of parameter descriptions and no output schema, the description is only partially complete. The enum helps explain the 'section' parameter, and the sibling tool list provides context, but 'handle' is undefined and the return value shape is not described. Still, as a deliberately heavy escape hatch, the description conveys the essential role.

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

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

Schema description coverage is 0%, so the description must compensate. It only vaguely connects 'section' to a 'named raw section' of the hierarchy, and it does not explain what 'handle' refers to or what each enum value means. The enum values are listed in the schema, but without descriptions the agent is left to guess their 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 states a clear verb and resource: 'return a named raw section of the full hierarchy result.' It also distinguishes itself from siblings by calling itself an 'escape hatch' and contrasting with 'targeted handle tools,' so an agent can understand this is the less-refined, broader alternative.

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 instruction 'Prefer targeted handle tools — this is intentionally heavy' explicitly tells the agent to favor alternatives when possible and warns that this tool is expensive. It does not name specific sibling tools or enumerate exact conditions for when the escape hatch is necessary, but it gives clear directional guidance.

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

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

Since no annotations are provided, the description carries the full burden—and it meets it. It discloses backend selection and fallback order (NPI, Source Graph, Legacy Static), traversal limits (4,096 states, 32 returned facts), truncation semantics, bounded bootstrap behavior, provenance fields, and the special testbench_driven interpretation. There is no annotation contradiction.

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 first sentence front-loads the purpose effectively, and each clause is technically meaningful. However, the entire description is one dense, unbroken paragraph with no bullet points or sections, making it harder for an agent to parse quickly. It is informative but not concise.

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 no output schema and significant conditional behavior, the description is exceptionally complete. It specifies result semantics (claim_semantics fields, backend_status), fallback order, truncation limits, per-hop provenance, and the testbench_driven special case, giving an agent enough to call the tool and interpret results 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 coverage is 56%, so the description must add some value. It does for key parameters: 'recursive=true' is explained as walking multiple hops upstream across instance boundaries, and allow_bounded_bootstrap is described as a resource-bounded exception that only returns proved positive facts. Other parameters like top_hint are not elaborated, but the schema already covers several.

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 opening sentence, 'Trace a waveform signal path back to the most likely RTL driver,' gives a specific verb, resource, and goal. It additionally scopes supported constructs (direct assigns, simple always blocks, module output ports), which helps distinguish it from siblings like trace_signal_path and find_signal_loads.

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 clear context for what the tool does and extensive guidance on interpreting its results, such as treating driver_status='testbench_driven' as 'start in the TB driver/BFM'. However, it never mentions sibling tools or conditions that would route an agent to an alternative, so usage vs. alternatives is only implied.

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 provided, the description carries the full behavioral disclosure burden, and it delivers exceptionally: it documents the full backend attempt chain, the 256-entry high-fanout cap with the warning that capped results are usable but not complete, absence of continuation tokens, normalization of trailing numeric selects per backend, and the source_info_origin provenance field. This is far more transparent than typical MCP descriptions.

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 purpose is front-loaded in the first sentence, which is good, but the rest is a dense single paragraph of backend-negotiation, result-semantics, and enumeration-contract detail. Every sentence carries information, yet the wall-of-text structure hurts navigability; details like the enumeration metadata contract and the 256 cap would sit more naturally with an output schema or in structured sections. It is verbose enough that a 3 is appropriate.

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 complex 9-parameter, 3-backend tool with no output schema, this is remarkably complete: purpose, load kinds, backend routing, fallback behavior, truncation semantics, provenance, and result-interpretation rules are all covered. The main gap is that it never specifies the concrete response shape of a load entry beyond carrying file:line and source_info_origin — the enumeration contract is described, but the load object's fields are not, which matters because no output schema exists.

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% (mid-range), so the schema already documents most parameters. The description adds genuine value beyond it: it maps the kind_filter enum values to concrete load kinds, explains that NPI's fan-out walk is internally depth-bounded regardless of max_depth, and clarifies allow_bounded_bootstrap's consequence that no-match is inconclusive and never triggers a rescan. Parameters like top_hint and simulator receive no extra elaboration, but the added semantics push this above the schema-only baseline.

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 opening sentence is a model of purpose clarity: 'List places that consume (load) a signal' with three concrete load kinds enumerated (child instance input ports, RHS of assigns/procedural assignments, always-block sensitivity lists). This specific verb+resource+scope immediately differentiates it from sibling tools like trace_signal_path or explain_signal_driver, which concern tracing/drivers rather than consumers.

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 strong conditional context for when the tool's modes engage: NPI when a Verdi KDB is detected, Source Graph when NPI is unavailable, Legacy Static as fallback, and the allow_bounded_bootstrap special behavior. It also gives clear interpretative guidance (exhaustive_search required before treating the list as all loads, negative_claim_allowed required before claiming there are none). However, it never explicitly names sibling alternatives or states when to prefer this tool over them, 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 provided, the description carries the full behavioral burden. It does disclose one meaningful constraint — that `path` and `module` are mutually exclusive — which is a genuine gotcha. But it omits the role of the required `handle` parameter, behavior when both path and module are supplied, no-match behavior, return shape, and the effect of `limit`. This is too thin for an annotation-free 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?

A single 18-word sentence, front-loaded with the core action and resource, followed by the two modes and the key constraint. Every word earns its place; there is zero redundancy or 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?

Despite the tool's moderate complexity (4 parameters, 1 required, no annotations, no output schema), the description leaves material gaps: the meaning of `handle`, return format, error/edge-case behavior, and how this tool relates to the large testbench tree tool family. An agent could call it correctly only by guessing at `handle` semantics.

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%: only `path` and `module` are described. The description adds real semantic value by stating these two are mutually exclusive, which is not present in the schema. However, it does not compensate for the two undocumented parameters, most critically `handle`, which is required and completely unexplained, and `limit`, whose interaction with path vs module mode is unclear.

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 ('Locate'), a specific resource ('instance(s) in the component_tree'), and two distinct search modes (exact path or module name). This is clear and functionally distinct from sibling tools like get_tb_subtree or lookup_tb_files, though it doesn't name them 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 the usage context: call this when you have an exact instance path or a module name to locate instances. However, it gives no exclusions and names no alternatives among the 38 siblings, so an agent gets no explicit guidance on when to prefer find_tb_instance over get_tb_subtree or lookup_tb_files.

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 provided, the description carries the full behavioral disclosure burden and does it thoroughly. It explicitly discloses read-only behavior ('only reads cache'), process-global cache persistence ('survives across cases'), and the carried_over edge case. This goes well beyond what the tool name alone reveals.

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 five sentences are dense and purposeful: what it is, its non-executing behavior, what it returns, how to use it at session start, and the fallback when no target is given. The critical constraints are front-loaded, and no sentence feels 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?

For a tool with no output schema, the description meaningfully describes return content ('availability status, compact summaries, and suggested calls for missing steps') and even names the carried_over signal. It also covers both usage paths — passing a target case and passing no target — so an agent has enough context to call and interpret the tool correctly.

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

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

The input schema already provides rich, detailed descriptions for both optional parameters, covering case validation and cold-start degradation, so the 100% coverage baseline applies. The description adds only a small 'verif_root and/or case_dir' combination hint and the no-target fallback, but largely restates schema semantics rather than offering materially new parameter meaning.

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

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

The description opens with a concrete role ('Cold-start accelerator') and a concrete action ('aggregates cached tool results into a single summary view'). It further distinguishes itself from the sibling debugging tools by stating 'It never triggers sub-steps and only reads cache.' This is a clear, specific definition rather than a tautology.

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 an explicit usage context: 'at the start of a new session pass your target case (verif_root and/or case_dir)'. It also names a relevant alternative when no target is passed: 'confirm it or re-run get_sim_paths.' It does not enumerate broader when-not-to-use scenarios, so it falls just 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?

No annotations are provided, so the description is the only source of behavioral info. It discloses the core read-only behavior ('Extract raw log text') and its relationship to parse_sim_log output. However, it doesn't state return format details (e.g., whether line numbers are included) or error-handling behavior, leaving some ambiguity for a no-annotation 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?

One concise sentence with the action upfront, followed by a usage pointer. No filler or redundant restatement of schema fields.

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

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

For a simple extraction tool, the description captures purpose, input source, and output nature ('raw log text'). It lacks explicit return formatting details but the workflow reference to parse_sim_log provides sufficient context for an agent 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 coverage is 100%, so the baseline is 3. The description adds meaning by indicating the 'line' parameter should come from parse_sim_log's first_line field, bridging tool outputs. This is helpful beyond the schema's 'Center error line number.'

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: 'Extract raw log text around a given error line.' This clearly distinguishes it from parse_sim_log (parsing) and diff/analyze tools. The phrase 'Typically used with parse_sim_log' further places it in the workflow.

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 explicit usage context: 'Typically used with first_line returned by parse_sim_log.' This situates the tool in the debug workflow but doesn't explicitly state when not to use alternatives like analyze_failures or diff_sim_failure_results.

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 present, the description carries the full behavioral burden. It does communicate a read-only query and an FSDB runtime dependency, but it omits the return format, exact-match-versus-nearest-time behavior, error behavior for unsupported FSDB files, and what happens when the signal cannot be resolved. This is too thin for a no-annotation 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 sentences with no filler: the first states the core operation and scope, and the second adds a necessary runtime caveat. The information is front-loaded and every sentence 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?

The tool has three required parameters, no output schema, and no annotations, so the description must cover both selection and invocation context. The schema covers time_ps and signal_path well, but wave_path is left undefined, and the return value/behavior is not described. An agent would likely be uncertain about what this tool returns and how to supply wave_path 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 already documents time_ps and signal_path in detail, and the description adds only the general notion of 'signal value' and the default unit 'ps'. The wave_path parameter has no schema description and the tool description does not compensate for it, so parameter semantics are adequate but not enhanced meaningfully beyond the schema.

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

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

The description clearly identifies the verb ('Query'), the resource ('a signal value in a waveform file'), and the key qualifier ('at a specific time in ps'). It distinguishes itself from siblings like get_signal_transitions and get_signals_around_time through the singular value/point-in-time framing, though it does not explicitly name or contrast those alternatives.

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 intended use case—fetching a single signal's value at one point in time—is implied by the description, but there is no explicit guidance on when to prefer this tool over closely related siblings such as get_signals_around_time or get_signal_transitions. The FSDB dependency note is a config caveat, not usage routing.

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 it excels: it discloses the server-enforced MAX_WAVE_WINDOW_CYCLES cap, runtime clock-period detection, rejection of center_time_ps past simulation end, FSDB dependency, and transient-flag semantics. This goes well beyond the schema and helps the agent anticipate non-obvious runtime behavior.

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 long but every paragraph carries unique, operationally relevant information: purpose, usage boundaries, window sizing, server limits, transient handling, and return-mode semantics. It is front-loaded with the core purpose and the most important exclusion, and the structure allows an agent to extract what it needs 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?

Despite no output schema and rich sibling context, the description covers the tool's behavior, constraints, units, edge cases, and mode variations. It explains how to convert units, what limits apply, what the transient fields mean, and when to prefer values_only, making it effectively self-contained for correct invocation.

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?

Even though schema coverage is 83%, the description adds substantial meaning beyond the schema: unit conversion from ns to ps with a concrete example, typical window_ps values for different inspection scenarios, the hard cap on window size, and the effect of return_mode='values_only' on returned fields. These details are not inferable from the schema 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?

States a specific verb and resource: 'Return values and transitions for multiple signals in a NARROW window around a target timestamp'. Explicitly contrasts with bulk extraction and names the alternative get_signals_by_cycle, so an agent can distinguish it from siblings 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?

Provides explicit when-to-use guidance: local causal-chain inspection around a failure time, not bulk trace extraction. Offers alternatives for round-by-round or multi-cycle sampling, gives typical window_ps values for glitch inspection and clock cycles, and clarifies when get_signals_by_cycle requires a clock_path.

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 only states the sampling alignment and use cases. It doesn't mention the non-obvious 1 ps post-delta offset, the 256-cycle cap, or the resolved_aliases/signal_suggestions behavior, though these appear in parameter descriptions. It is not misleading but is minimal for a tool with this many behavioral nuances.

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 first states the core function with a specific verb and object, the second gives use cases. The 'aligned to a clock edge' qualifier is front-loaded in the first sentence.

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 description is effective for a moderately complex tool because the schema covers parameter semantics and the first sentence establishes the sampling model. However, with no output schema, the description doesn't specify the result structure or mention the alias-resolution output, leaving some ambiguity for an agent. The use-case sentence helps compensate, but a note on return shape would make it fully complete.

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 baseline is 3 and the description adds little beyond naming 'multiple signals' and 'clock edge.' The input schema already documents each parameter, including mutual exclusions and defaults, so the description doesn't need to compensate. Score reflects that the schema carries the 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?

States a concrete action: 'Return cycle-by-cycle sampled values for multiple signals aligned to a clock edge.' The 'cycle-by-cycle' qualifier clearly distinguishes it from sibling time-domain tools like get_signal_at_time and get_signals_around_time. Also provides domain context with state machines, pipelines, and round-by-round algorithm checks.

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 ties use to cycle-aligned analysis: 'Useful for state machines, pipelines, and round-by-round algorithm checks.' This gives an agent a clear heuristic for when to select this tool, though it doesn't name alternatives or exclusion criteria. The sibling list reinforces the distinction from time-based sampling tools.

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 provided, the description carries the full behavioral burden and does well: it discloses the strict closed range, the default 1000 cap, the truncated=true/hint convention, that transition_count is always the total, that predecessor is kept separate, and that FSDB support depends on a runtime flag. This is substantial transparency, though FSDB failure behavior remains slightly underspecified.

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 sentences pack a lot of relevant behavioral information without filler. The parenthetical-heavy middle sentence is dense, but every clause adds value. The core operation is stated first, followed by edge-case semantics.

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 there is no output schema, the description covers the key return-related behaviors: truncation, hint marking, transition_count semantics, and predecessor handling. It is slightly vague about what happens when FSDB support is disabled, but overall an agent has enough context to invoke the tool and interpret results.

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 already documents start_time_ps, end_time_ps, and max_transitions with type and unit details, and the description adds meaningful semantics beyond that: the strict closed window, the default cap behavior, the truncated hint, and the separate predecessor rule. It does not add much on wave_path/signal_path, but those are self-explanatory.

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 ('Return') and resource ('transitions for a signal') with a precise time range and cap behavior, making the tool's core purpose clear. It is distinguishable from sibling tools like get_signal_at_time or get_signals_around_time, though it does not explicitly name or contrast them.

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

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

The description implies when the tool is appropriate—any time a signal's transitions over a range are needed—and provides guidance like 'prefer narrowing the time range' and 'Raise explicitly only for deliberate bulk extraction.' However, it does not explicitly state when to choose this over sibling tools such as get_signal_at_time or get_waveform_summary.

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 provided, the description carries the behavioral burden and does well: it discloses that explicit fields are used verbatim, omitted fields are auto-discovered, and a sim_log path also anchors discovery of related files. It does not explicitly state read-only/no-side-effect status, but 'discover' implies a non-mutating operation.

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 sentences with no filler: the core purpose is front-loaded, followed by concise conditional behavior for omitted case_name and explicit path overrides. Every sentence contributes useful 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?

The description covers the main parameter interactions and conditional return behavior, which is important given there is no output schema or annotations. It does not spell out the exact return JSON shape, but the implied result (paths and/or case list) is sufficient for an agent to invoke the tool successfully.

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 already documents every parameter with 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by explaining cross-parameter behavior: provided paths are used as-is, omitted ones are auto-discovered, and sim_log anchors the discovery of matching waveform/compile logs.

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

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

The description opens with a specific verb ('Discover') and names the exact resource types: compile logs, simulation logs, and waveform files under a verif directory. This clearly distinguishes it from analysis/parsing siblings such as parse_sim_log or get_waveform_summary.

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 actionable when-to guidance: omitting case_name returns available cases, and explicit paths are intended for non-standard layouts. It does not explicitly name alternative tools, but the main conditional usage is clearly conveyed.

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 must carry the full burden. It discloses the data source (compiled-source scan) but omits effects, return format, traversal order, depth semantics, and error behavior. The word 'Return' suggests a read operation, but safety and performance characteristics are not stated.

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, both essential, with the primary operation first and the parameter behavior second. It earns conciseness but could use the saved space to explain remaining 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?

Without an output schema or annotations, the description must describe return values, parameter semantics, and usage context. It covers only root_class and leaves handle, depth, and return structure unaddressed, making it insufficient for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains root_class meaning and empty behavior, but handle (required) and depth are left completely unexplained.

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 'Return' and a specific resource 'UVM/class inheritance tree' from 'compiled-source scan results'. It clearly identifies the tool's purpose but does not explicitly distinguish it from sibling tools like get_tb_subtree or build_tb_hierarchy.

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 guidance on when to choose this tool over get_tb_subtree, build_tb_hierarchy, or other hierarchy-related tools. The only usage hint is how to use root_class, which is parameter-level instruction, not tool-selection guidance.

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

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

With no annotations provided, the description carries the full burden of disclosure. It does usefully mention the error-suggestion behavior when the path is not in the compile set, which is a real behavioral trait. However, it does not address whether the operation has side effects, preconditions like a prior build, or any caveats about the compiled set.

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. The main action is front-loaded, and the conditional error behavior is added compactly. Every sentence contributes.

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 two wholly undocumented required parameters, the description is not complete enough. It explains what is returned and one error scenario, but omits the role of 'handle', the output shape, and any preconditions, leaving an agent to guess before invoking.

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 clarify both parameters. It gives only indirect meaning for 'path' via the compile-set/error-suggestion note, but 'handle' is entirely unexplained. This is insufficient for an agent to know what values to provide.

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?

Description begins with a specific verb ('Return') and identifies a precise resource: symbols (modules/classes/interfaces) defined in a single compiled file. This is clear and actionable, but it does not explicitly differentiate from siblings like get_tb_subtree or lookup_tb_files beyond the implicit 'single compiled file' scope.

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 guidance is given about when to choose this tool over alternatives, nor any when-not-to-use conditions. The only behavioral note is about error suggestions for wrong paths, which is not usage routing.

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 provided, the description must carry the behavioral disclosure burden. It does: "Return a slice" signals a non-mutating read operation, and "without pulling the whole tree into context" reveals a deliberate context-size-limiting behavior. It also exposes the prerequisite relationship with build_tb_hierarchy. It does not explicitly mention error behavior or output structure, but the core behavioral profile is clear enough for an agent.

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 tight sentences. The first sentence states the operation and key parameters; the second adds usage context. No filler or redundant phrasing exists, and the most important action is front-loaded.

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 four-parameter tool with no output schema and no annotations, the description conveys what it returns, how to invoke it (after build_tb_hierarchy), and why to use it (context minimization). It does not describe the exact shape of the returned slice or edge-case behavior, but the parameters and sibling context fill most gaps, leaving only minor ambiguity.

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 each parameter already has a description (root, depth, handle, max_nodes). The tool description only re-states root and depth in prose and does not add meaning beyond the schema. Therefore the baseline of 3 is appropriate; the schema already does the explanatory 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?

The description begins with a specific verb and resource: "Return a slice of the component_tree" and clarifies the input key "root (dotted instance path)" with "up to `depth` levels." It clearly differentiates from full-tree-building tools by stating it "drill[s] into a branch" rather than pulling the whole tree.

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 second sentence explicitly gives the intended usage context: "Use after build_tb_hierarchy" and explains the benefit: "without pulling the whole tree into context." This provides clear when-to-use guidance, but it does not name alternative tools or explicitly state when not to use it, so it stops short of a fully exclusive routing.

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 disclose behavior itself. It communicates that the operation is read-only ('Return') and exposes the condition 'FSDB support depends on fsdb_runtime.enabled.' However, it does not explain what happens when fsdb_runtime.enabled is false, whether errors occur, or how limitations manifest.

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 wasted words. The primary purpose is front-loaded, and the non-obvious FSDB runtime requirement is placed second without clutter.

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 one-parameter tool, the description gives useful return-value examples and a key dependency warning. But because there is no output schema and no annotations, the description leaves ambiguity around exact return structure, error behavior, and what 'depends on fsdb_runtime.enabled' means operationally.

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 provides only 'wave_path' as a required string with 0% description coverage. The tool description does not explain the expected path format, supported waveform file types, or how wave_path interacts with the FSDB dependency, so it fails to compensate for the missing schema documentation.

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 ('Return') and resource ('basic waveform metadata') with concrete examples ('format, duration, and top modules'). This clearly distinguishes it from sibling tools that operate on signals, traces, or structural hierarchy.

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 intended use is implied: call this when you need summary-level waveform metadata rather than signal-level analysis. The FSDB dependency hints at when the tool may not work, but there is no explicit comparison to alternatives or guidance on which sibling tools to choose instead.

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 provided, the description carries the full burden, and it delivers: it discloses that this tool only reads waveforms and does NOT rerun simulation, that it auto-registers a cursor at the first problem, that one-sided violations are attributed to the valid driver, and that AHB returns a protocol_semantics receipt. This is unusually rich behavioral disclosure.

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 long but earns most of its length by covering six checks, four protocol shapes, cursor behavior, and attribution semantics. It is front-loaded with the core classification purpose. A few clauses are dense or redundant, such as the HWDATA-hold being explained twice and the awkward phrase 'leave no value pattern in scoreboard logs', which keeps it from a 5.

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?

Even though there is no output schema, the description tells the agent what to expect from the tool: coverage facts for the checks actually run, a registered cursor at the first problem, a structured attribution block for one-sided violations, and an AHB protocol_semantics receipt. It also distinguishes the empty attribution for plain two-sided stalls. For an 18-parameter, analysis-heavy tool, this is remarkably complete.

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. The description adds meaningful semantics beyond the schema: it explains why HWDATA must be passed as write_data rather than payload, which side may safely pass write_data, how valid_htrans derives valid, and what max_wait_cycles defines as a long stall. It does not restate every parameter, but it adds genuine interpretive value.

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 opening sentence names the exact operation ('Classify a clocked valid/ready handshake cycle-by-cycle') and enumerates concrete outputs such as stall windows, backpressure imbalance, and payload-hold violations. It is clear and specific, but it does not explicitly contrast with nearby siblings like sweep_handshakes or reconstruct_transactions, 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?

The description gives strong protocol context (AXI, AHB, generic, credit) and practical constraints such as 'For AHB do NOT include hwdata here' and 'Pass it ONLY for the producer/initiator interface'. However, it never states when to prefer this tool over a sibling or when not to use it, so the selection guidance is implicit rather than explicit.

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 behavioral burden. It conveys that this is a read-style query over the compiled file set, that a filter is mandatory, and that basename-collision information overlaps with build_tb_hierarchy. It does not discuss pagination, error behavior, or return shape, but these are secondary for a query tool and the core behavior is clear.

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 that front-load the action and resource, then state the constraint, then give the primary use case. There is no filler, repetition, or unnecessary 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?

This is an 8-parameter tool with no output schema and no annotations, so the description needs to carry more weight. It omits return behavior, filter-combination semantics, and the meaning of the required handle parameter. The stated use case is helpful, but an agent would still be guessing about important invocation details.

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 50%, and the description does not compensate for the undocumented parameters. In particular, the required 'handle' parameter is never explained, and 'limit', 'name_contains', and 'path_contains' also lack meaning beyond their names. The 'at least one filter' constraint is useful but does not clarify whether handle counts as a filter or what formats are expected.

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

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

The description opens with a specific verb ('Query') and resource ('compiled file set'), then gives a concrete purpose: disambiguating multi-version files. It also references a related reporting channel, build_tb_hierarchy.ambiguous_basenames, which helps distinguish it from sibling lookup tools.

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

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

The description explicitly states that at least one filter is required and recommends this tool for disambiguating multi-version files, mentioning that basename collisions are also surfaced by another tool. It does not enumerate exclusions or explicitly say when to prefer other siblings, so it stops 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 provided, the description carries the full burden of behavioral disclosure, and it does so well: it calls out non-auto-detection, bounded evidence sampling, exclusion of compile/elaboration logs, and the automatic inclusion of about 100 lines of context for the first group. It does not discuss output shape or error behavior in depth, but the disclosed behaviors are meaningful and specific.

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 deliver the core purpose first, then key caveats, then routing advice. Every sentence contributes new information, and none of the schema's parameter descriptions are redundantly restated.

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 there is no output schema, the description helpfully names and explains two output-related concepts (candidate_previous_logs and first_group_context) and points to get_error_context for richer context on other groups. It is complete enough for an agent to understand what the tool returns and how to use it, though a bit more about the overall result structure would make it fully self-sufficient.

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 already describes all five parameters with 100% coverage, so the baseline is 3. The description adds context beyond the schema by explaining that simulator is not auto-detected and that first_group_context is automatically populated, which is helpful, but it does not need to repeat parameter definitions.

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 ('Parse'), the exact resource (VCS or Xcelium simulation log), and the specific output (grouped runtime failures by signature). It also differentiates itself from sibling tools by noting that get_error_context should be used for other error groups, making the purpose unmistakable.

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 clearly indicates that the simulator argument is required and not auto-detected, which prevents a common misconfiguration. It also says candidate_previous_logs excludes compile/elaboration logs and directs users to get_error_context for non-first groups, giving practical routing guidance, though it could more explicitly state when to prefer this tool over analyze_failures or diff_sim_failure_results.

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 provided, the description carries the full burden, and it does so well. It discloses that the tool only reads existing waveforms and does NOT rerun simulation, and it reveals the important side effect that the first off-beat is auto-registered as a cursor. It also defines the dominant period as the median edge-to-edge interval, clarifying the internal behavior.

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 sentences with no wasted words: the first states the core action, the second gives concrete use cases, and the third explains the algorithm, side effect, and read-only safety. The key differentiators are front-loaded.

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 eight parameters and no output schema, the description covers the important behavioral context: when to use it, how the period is computed, the cursor side effect, and the read-only guarantee. The only gap is that the return value is not explicitly described, which matters because no output schema exists.

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 input schema already documents every parameter in detail. The description adds some context through the 'window' and 'beat' language, but it does not add meaning 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 uses a specific verb ('Estimate', 'flag') and names the resource ('a signal's dominant period inside a window'), then adds the exact calculation method (median edge-to-edge interval). It distinguishes itself from rhythm/throughput alternatives by explicitly scoping to cases an LLM cannot eyeball from a transition dump.

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 clearly states when to use the tool: for rhythm/throughput questions such as stalled clocks, dropped burst beats, backpressure bubbles, and irregular strobes. It also conveys that this is for cases an LLM cannot eyeball, which implies a rough when-not boundary, though it does not name specific alternative sibling tools or explicit 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 behavioral burden, and it does so fairly well: it frames the tool as advisory ('recommend', 'suggests') rather than executing diff_sim_failure_results itself, and it discloses the output categories. It is silent on session state effects and no-failure edge cases, but these are less critical for an apparent read-only recommendation 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: the primary action and inputs are front-loaded, the output categories follow, and the diff_sim_failure_results suggestion is a single extra clause. No filler or repetition.

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

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

For an analysis/recommendation tool with no output schema or annotations, the description gives enough high-level shape to make a reasonable call: required inputs are implied, and outputs are named. It leaves the exact response structure, the meaning of compile_log, and the form of the suggested diff_sim_failure_results call undefined, so an agent would still need to infer some integration details.

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 adds meaning beyond the schema by relating log_path, wave_path, and top_hint to 'current log, waveform, and optional hierarchy', and the schema itself documents simulator as 'vcs / xcelium'. However, compile_log is never explained, so the 20% schema coverage is only partially compensated.

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 is specific: it chooses the highest-priority failure and recommends signals, instances, and suspected failure class, which goes well beyond the tool name. It also names the data sources (log, waveform, optional hierarchy) and the downstream diff_sim_failure_results suggestion. It does not explicitly contrast itself with overlapping siblings like analyze_failures or get_diagnostic_snapshot.

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 use context is implied rather than stated: 'current log, waveform' and 'on the next run' signal a post-simulation debugging stage. There is no explicit guidance about when to choose this tool over alternative analysis/debug tools, nor any 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 full behavioral burden and does so well: it discloses read-only operation, algorithmic behavior (per-id FIFO, out-of-order support), interpretive caveats (reorder_count is informational, latency is a distribution not verdict), and hang semantics (unmatched=hang signature). This goes well beyond the schema.

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 dense yet tightly constructed. The first sentence encapsulates purpose, method, and outputs; subsequent sentences add protocol mappings and key caveats. There is no filler, and every clause contributes to effective tool selection and invocation.

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 27 parameters, no output schema, and no annotations, the description is remarkably complete. It explains the core algorithm, protocol-specific parameter meanings, optional payload capture, burst-length checking, reset handling implications, and result semantics. An agent has enough context to invoke the tool correctly across AXI read/write and simple in-order scenarios.

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. The description adds valuable cross-references and protocol mappings, such as explaining that req_len triggers beat_count_mismatch checks and how cmp_last affects transaction completion. It enriches the schema without repeating it verbatim.

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 identifies the tool's function with a specific verb ('reconstruct'), resource ('id-correlated request/response transactions from two handshake channels'), and method ('walk every clock edge, match accepted request beats to completion beats by id'). It distinguishes itself from sibling waveform/signal tools by focusing on transaction-level reconstruction and latency/fact output rather than signal inspection.

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 strong contextual guidance, including exact AXI READ/WRITE signal mappings and when to use optional parameters (req_fields/cmp_fields, req_len, cmp_last). However, it does not explicitly name alternatives or exclusion conditions among sibling tools, though none appear to be direct alternatives.

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 provided, the description carries the full burden, and it largely succeeds: it explicitly warns that results are 'suspicious patterns, not confirmed root causes' and explains what 'complete', 'zero_coverage', and 'degraded' mean for drawing a clean-scan conclusion. This is meaningful behavioral context beyond the schema. It does not discuss side effects or permissions, but for a read-style scan tool the key caveats are 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?

The description is three sentences with no filler: it front-loads the action, then gives the heuristic caveat, then the output-interpretation rule. Every sentence earns its place, and the dense coverage_status guidance is necessary rather than 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?

For a tool with one required parameter and complete schema descriptions, the description provides the key result-handling context via coverage_status and total_risks, even though no output schema exists. It does not describe the full risk report structure, but an agent can correctly invoke the tool and understand the critical status field. Minor output-shape detail is the only real gap.

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 structured data already documents all four parameters. The description adds mild context by tying compile_log to the 'compile file list', but it does not add semantics for simulator, categories, or scan_scope beyond the schema. Given full schema coverage, 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 opens with a concrete imperative: 'Run a Scope 1 regex-based structural risk scan on RTL/TB source files from the compile file list.' This states a specific verb and resource and clearly distinguishes 'structural risk scan' from the many log-parsing, waveform, and TB-navigation siblings. The heuristic qualifier further sharpens what the tool does.

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

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

No sentence states when to choose this tool over a sibling or when not to use it. The coverage_status advice explains how to interpret results after running the scan, not how to select among alternatives. Usage context is only implied by the tool's name and 'risk scan' language.

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 and does this well: it discloses VCD's null direction behavior, FSDB populating both fields, scope-tree indexing, the fact that no value changes are read, scaling characteristics, and the fsdb_runtime.enabled dependency. This is substantial behavioral context beyond the schema.

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 long but dense and well-structured: purpose first, then usage context, batch semantics, result fields, format limitations, and backend notes. Every sentence contributes information an agent needs; there is no filler or repetition.

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

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

The tool has no output schema and no annotations, yet the description explains what results contain, their order, backend-specific caveats, and a runtime prerequisite. An agent has enough detail to decide when to call it and how to interpret the response.

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. The description adds meaningful semantics for keyword: batch behavior, input-order result entries, the preference for lists, and using hierarchical keywords with direction/var_type for filtering. It does not add extra semantics for wave_path or max_results, which the schema already covers adequately.

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

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

The description opens with a specific verb and resource: search for signals in an FSDB/VCD waveform file and return full hierarchical paths. It also clarifies the tool is for name-based lookup, distinguishing it from sibling tools that work with signal values or transitions.

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 states when to use this tool: when the client knows a leaf signal name but not the full path. However, it never names sibling alternatives or gives explicit when-not-to-use conditions, so it falls just short of full usage guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool reads existing waveforms only, pairs valid/ready signals by scope and stem, finds the clock, and groups payload buses. It also explicitly discloses a non-obvious limitation for AHB. This is rich, honest behavioral 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 is four sentences, each earning its place: the core function, the recommended workflow, supported protocols, and an explicit exclusion with a pointer to the alternative. It is front-loaded with the primary purpose and contains 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 tool with no output schema, the description tells the agent what to expect (bundles containing clock, valid, ready, payload), how to use the results (feed into inspect_handshake), and what limitations exist. Combined with full schema coverage, an agent has everything needed 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 coverage is 100% and every parameter already has a clear description, so the baseline is 3. The tool description adds a slight hint about scope ('by scope and stem') but does not materially expand on the schema's parameter documentation. It neither improves nor degrades parameter understanding.

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 ('Scan a waveform and propose'), a specific resource (waveform), and a concrete output (inspect_handshake bundles). It clearly distinguishes itself from the sibling suggest_protocol_bundles by name and scope, so there is no ambiguity about what this tool does.

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

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

The description explicitly tells the agent when to use it ('Use this BEFORE inspect_handshake') and when not to ('does NOT synthesise an AHB valid ... use suggest_protocol_bundles for AHB/APB'). It also enumerates supported protocols (AXI, generic valid/ready, req/ack), giving clear selection criteria.

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 delivers: read-only behavior is stated, the initiator-only HWDATA withholding is explained with rationale ('interconnect-mux output that glitches at the clock edge... to stay zero-FP'), and the direction_tag degradation rule ('unknown/conflicting markers degrade to direction_tag=\'unknown\' rather than guessing') is disclosed. This is exemplary behavioral disclosure beyond the schema.

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 purpose is front-loaded in the first sentence, and every subsequent clause adds distinct behavioral or domain value. It is long, but the length is warranted by the tool's protocol-specific complexity; a modest trim of parentheticals would be possible without losing substance.

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?

This is a complex tool with no annotations and no output schema, and the description compensates well by specifying candidate contents per protocol, the directional caveats, and the read-only safety property. The main gap is that the exact return structure/shape is not spelled out, leaving some inference about how candidates are packaged.

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 baseline is 3. The description adds meaning beyond the terses enum: it explains exactly what AHB candidates contain (valid_htrans + ready + payload, plus hwrite/write_data only on initiator interfaces) and what APB candidates contain (psel/penable/pready + derived-valid requirement), substantially enriching the protocol 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 opening sentence, 'Scan a waveform for protocol-specific AHB/APB bundles,' states a specific verb, resource, and scoped protocol family. The detailed AHB-vs-APB candidate descriptions (inspect_handshake args, valid_htrans, psel/penable) clearly separate this from siblings like suggest_handshakes.

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 strong context for when the tool is appropriate: AHB/APB protocol discovery, initiator-side versus responder-side handling, and the APB derived-valid caveat. It also adds the constraint 'Reads existing waveforms only.' However, it never explicitly names alternatives (e.g., suggest_handshakes) or states when not to use this tool.

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 provided, the description carries the full burden of behavioral disclosure. It clearly states the tool reads existing waveforms only (read-only behavior), returns facts not root-cause verdicts, propagates FSDB truncation as degraded coverage, and defines zero_coverage as a non-pass condition. It also discloses the ordering by a mechanical key and partial-coverage 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 dense but each sentence contributes a distinct operational fact: purpose, when-to-use, coverage semantics, retry policy, truncation handling, return type, and read-only nature. It is slightly long, but the complexity and lack of annotations/output schema justify the length.

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 complexity and the absence of both annotations and an output schema, the description covers everything needed: the fact-table fields, coverage_status interpretation, truncated/degraded meanings, FSDB truncation caveats, read-only nature, and the distinction between facts and verdicts. An agent can correctly select, invoke, and interpret the 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?

Schema description coverage is 100%, so the baseline is 3. The description adds general context about sweeping over a window and interpreting coverage, but it does not materially add parameter-level meaning beyond what the schema already provides. The scope retry advice is already present in the schema's scope field 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 action (whole-design handshake anomaly sweep) and resource (valid/ready and AHB interfaces), and lists the concrete checks performed. It also differentiates from siblings like suggest_handshakes and inspect_handshake by explicitly noting that it collapses N suggest+inspect round-trips into one.

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 to use the tool on opaque global symptoms (timeout/hang) when the offending interface is unknown, and contrasts it with the alternative suggest_handshakes + inspect_handshake flow. It also provides workflow follow-up guidance, such as not blindly replaying unscoped zero-coverage results.

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 provided, the description carries the full burden, and it does so thoroughly. It discloses the trusted Verdi NPI priority, the bounded TraceWeave Source Graph fallback, the non-exhaustive nature of a found path, the exactness condition for no-path results, and the unsupported_reason fallback. This prevents an agent from over-trusting or misinterpreting results.

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 dense but every sentence earns its place, covering purpose, algorithm priority, exactness caveats, and an important sibling distinction. It lacks any structural formatting such as bullets, making it somewhat hard to scan, but there is no wasted wording.

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 description gives substantial behavioral and result-caveat context, including claim_semantics, negative_claim_allowed, and unsupported_reason. However, with no output schema and incomplete parameter explanations, some important call details are left to inference. It is adequate for a knowledgeable agent but not fully complete.

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 only 33%, and the description does not compensate for the missing parameter guidance. The required parameters compile_log, from_signal, and to_signal are never explained beyond general phrasing, and top_hint is not mentioned at all. The schema's expand_assigns description is useful, but the core required parameters remain underdocumented for an 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 first sentence states a specific verb and resource: 'Find a structural connectivity path between two signals.' The last sentence explicitly distinguishes this from temporal driver semantics and names the appropriate sibling tool, explain_signal_driver, so an agent can reliably separate the two.

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 clear context for when to use this tool: when structural connectivity between two signals is needed. It explicitly tells agents not to use it for driver semantics and points to explain_signal_driver as the alternative. It doesn't compare against other siblings like trace_x_source or search_signals, but the main exclusion is well handled.

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 and succeeds: it discloses chain restarts on backend/artifact changes, never mixing provenance, backend_status vs trace_restarted fields, lock-free connectivity queries, and preserved claim_semantics/NPI evidence. This is unusually thorough.

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 main use case is front-loaded in the first sentence, and subsequent sentences each add a distinct behavioral fact rather than filler. It is dense but could be easier to scan with structured bullets.

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 complex tool with no annotations and no output schema, the description covers route selection, restart semantics, output status fields, and node-level semantics well. The main remaining gap is the lack of a clearer result-shape explanation, though the description provides substantial context.

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 43%, and required parameters like wave_path, signal_path, and compile_log lack descriptions in both the schema and the tool description. The description references 'target time' and 'original signal' but does not explain how the required inputs should be provided.

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 first sentence states a precise trigger (signal shows X/Z at a target time) and a concrete action (trace propagation chain through upstream driver logic). This clearly scopes the tool and distinguishes it from generic siblings like trace_signal_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?

The description explicitly scopes invocation to X/Z-at-time cases and describes the connectivity route fallback order. It does not name an alternative tool or provide when-not-to-use guidance, but the context is clear enough for correct 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 are provided, so the description carries the full behavioral burden. It discloses edge-case handling: x/z cycles are reported as unknown and never silently passed; an implication running past end-of-trace is inconclusive and never silently failed. It also reveals side effects/outcomes: on a finding it sets violating_signal plus next_action to explain_signal_driver, and notes that two calls are needed for OR 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 long but dense and every clause earns its place. It front-loads the core purpose, then efficiently covers templates, modes, edge cases, output behavior, and intended use. Semicolon-separated lists and mode names keep complex information scannable.

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?

There is no output schema, so the description appropriately explains return behavior: verdict, witness/counterexample with cycle and sampled values, vacuous pass/warnings, inconclusive results, and the violating_signal/next_action mechanism. For a tool with 14 parameters, nested objects, and multiple mode-dependent parameter sets, the description is complete enough for an agent to select and 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 100%, so the baseline is 3. The description adds meaningful semantic guidance beyond the schema: term format, implicit AND, mode-specific intent, overlap behavior for |=> stability properties, and concrete examples like AHB haddr + stride and restart_when for burst boundaries. It does not exhaustively walk through all 14 parameters, but it covers the semantically tricky ones such as delta, overlap, and restart_when.

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

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

The description opens with a specific verb and resource: "Evaluate a temporal predicate over a clock window and return a precise verdict (holds) plus a concrete witness/counterexample." It enumerates the five modes and the term/predicate structure, making the tool's unique role unmistakable among siblings like get_signal_at_time and search_signals. It also clarifies read-only scope with "Reads existing waveforms only."

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 a clear use case: "Use to prove/disprove an RTL inference in one call." It also provides mode-level guidance, e.g., implication as the protocol-response template, overlap=false for stability/hold properties, and sequence for address-stride checks. It does not explicitly name sibling alternatives or state when not to use this tool, 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.