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

No annotations present, so description fully covers behavior: compares reference-tree counts (not cycles), classifies into specific categories with confidence scaling, and explains co-occurrence escalation logic. Output structure detailed.

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?

Well-structured with clear front-loading of purpose, but somewhat verbose with detailed examples and classification logic. Could be trimmed while retaining value.

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

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

No output schema, but description thoroughly explains return structure (growthByClass array with classification, confidence, hint). Covers all necessary context for a complex memory analysis 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 coverage is 100% with descriptive parameter descriptions. The tool description does not add extra meaning beyond what's in the schema, so 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 clearly states it compares two .memgraph snapshots on heap reference-tree class counts and classifies growth shapes, distinguishing it from diffMemgraphs which only handles cycles. The verb 'analyze' and resource 'abandoned memory' are specific.

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?

Explicit workflow provided: pair with verify-fix loop using captureScenarioState before/after, and a real validation example. Implicitly suggests when not to use (e.g., cycle-only bugs) by contrasting with diffMemgraphs.

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 fully convey behavioral traits. It states it 'parses' and 'returns' data, implying a non-destructive read operation, but does not mention side effects, permissions, or performance characteristics. The description lacks detail on what happens if the trace is malformed or incompatible.

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

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

The description is a single sentence that efficiently captures the tool's purpose and return values. However, it is dense and could benefit from a more structured format (e.g., bullet points) for better readability.

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 lists returned data (aggregates, top allocators, diagnosis) but does not explain the output structure in detail. With no output schema, the description should cover error conditions, prerequisites (e.g., trace must be from Allocations template), and how the diagnosis is formed. The tool is part of a large sibling set, but its niche is clear.

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

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

Schema description coverage is 100%, so the schema already documents all parameters well. The description adds minor value by providing the xcrun command example for tracePath and clarifying outputFormat values, but does not significantly enhance understanding 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?

Description clearly states it parses the 'allocations' schema from a .trace bundle recorded with the Allocations Instruments template. It distinguishes itself from siblings like analyzeMemgraph (which analyzes general heap) and analyzeMemoryFootprint (which focuses on footprint breakdown) by specifying the exact schema and template used.

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

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

The description implies usage for analyzing allocation data from a specific trace template, but does not explicitly state when to use this tool versus siblings like analyzeMemgraph, analyzeMemoryFootprint, or compareTracesByPattern. No when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description bears full burden. It describes the tool as parsing and returning data, implying non-destructive behavior. However, it lacks explicit disclosure of behavioral traits such as read-only nature, performance characteristics, or any side effects, which would be helpful 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 sentences long, front-loads the key action and schema, and contains no redundant information. Every sentence adds value.

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 5 parameters, full schema coverage, and no output schema, the description adequately conveys the overall purpose and return shape. It could be enhanced by briefly noting the response format options (e.g., JSON/markdown) but is largely complete for typical use.

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 base is 3. The description adds overall behavioral context (what the tool returns) but does not add specific parameter semantics beyond what is already in the schema. The summary of return values is useful but not parameter-level detail.

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

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

The description clearly states that it parses the `animation-hitches` schema from a `.trace` bundle, enumerates the outputs (hitch totals, by-type counts, longest hitches, 100ms threshold crossing), and implicitly distinguishes itself from siblings like `analyzeHangs` or `analyzeTimeProfile` by its specific domain.

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

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

The description implies usage for animation hitch analysis from a specific `.trace` bundle recorded with the Animation Hitches template, providing clear context. However, it doesn't explicitly exclude other scenarios or compare directly with sibling tools, leaving some ambiguity about when to prefer this over others.

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 present, so the description carries full burden. It describes parsing and returning data but does not explicitly state whether the operation is read-only, or disclose side effects, error handling, or limitations. However, the name 'analyze' suggests non-destructive behavior, and the description is adequate for an analysis tool.

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

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

The description is two sentences long, front-loaded with the action ('Parse the app-launch schema') and followed by a list of returned data. Every word is informative with no 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 tool has only two parameters, no output schema, and no annotations, the description adequately covers purpose, input requirements, and output contents. It is missing error conditions or usage examples, but for a focused analysis tool it is largely 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 baseline is 3. The description adds minimal value beyond the schema for 'tracePath' (same info) and some added context for 'outputFormat' (default behavior and special case for other tools). Overall, it does not significantly enhance 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 uses specific verbs ('Parse', 'Returns') and explicitly names the resource ('app-launch schema from a .trace recorded with the App Launch Instruments template'). It clearly distinguishes from siblings like 'analyzeAllocations' by specifying the template. The output contents (total launch time, type, per-phase breakdown, slowest phase) are detailed.

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 states the input must be a .trace file recorded with the App Launch template, providing clear context. It does not explicitly state when not to use this tool or list alternatives, but the sibling tool names imply each analyze tool targets a specific template.

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 burden. It discloses that it parses the trace, returns bucket classification, wakeup count, active-state ratio, and top-N samples. It mentions v1.15+ but does not specify side effects or error handling. Lacks explicit read-only statement, but the nature of trace analysis implies no destructive actions.

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 relatively concise and front-loaded with the core purpose. It uses brackets to highlight the tool source, and includes version info. Every sentence adds value, though it could be slightly more structured.

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

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

No output schema exists, so the description must explain return values. It lists returned items (classification, wakeup count, ratio, top-N) but lacks details on format or structure. For a tool with 3 parameters, this is adequate 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 coverage is 100% with descriptions for all three parameters. The description adds context like 'top-N samples by energy cost' but does not provide additional semantic value beyond what the schema already offers. 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 states the tool parses the energy-impact schema, returns classification and aggregate data, and distinguishes itself from analyzeTimeProfile by specifying it reads the OS power-management subsystem directly. The verb 'Parse' and resource 'energy-impact schema' are specific.

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

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

Explicitly mentions the use case 'why is my app draining battery?' and distinguishes from analyzeTimeProfile. However, it does not provide guidance on when not to use or alternative tools among the many siblings, but the single distinction is clear.

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?

Despite no annotations, the description transparently explains the tool's behavior: it runs xctrace export for potential-hangs schema, and optionally exports time-profile schema in parallel when includeStackClassification is true, with graceful fallback. It also describes the enrichment process and the effect of parameters.

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

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

The description is a single focused paragraph that is well-structured: starts with the core purpose and then systematically details parameters and usage. Every sentence adds value, with no fluff.

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, the description fully explains the return values (aggregated stats and top N hangs with optional enrichment). It covers all parameters, including the newer includeStackClassification and outputFormat, and mentions fallback behavior, making it complete for the tool's functionality.

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%, but the description adds significant meaning beyond the schema by explaining the pipeline for topFramesByHangStartNs, the recommendation for minDurationMs, and the behavior of includeStackClassification and outputFormat options.

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

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

The description clearly states the tool analyzes potential hangs from .trace bundles by running xctrace export and returning aggregated stats and top hangs. It distinguishes from siblings like analyzeTimeProfile by focusing specifically on hang analysis.

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 guidance on when to use parameters: suggests minDurationMs:250 for user-visible hangs, explains the typical pipeline with analyzeTimeProfile, and clarifies that includeStackClassification supersedes topFramesByHangStartNs for most callers.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It clarifies that the tool parses a trace file and returns analysis results, implying a read-only operation. However, it does not explicitly address error handling (e.g., invalid trace path, missing leaks data), performance implications, or required permissions. The behavioral information is adequate but not comprehensive.

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 exceptionally concise: three sentences plus a version note. It front-loads the core action ('Parse the leaks schema from a .trace'), immediately distinguishes from alternatives, lists outputs, and gives a concrete use case. Every sentence is essential and no information is repeated or wasted.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description provides a solid overview of purpose, output, and differentiation. It describes what the tool returns (four specific metrics), which partially compensates for the missing output schema. However, it does not cover possible errors, performance when processing large traces, or the exact format of timestamps, leaving minor gaps.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds value by explaining the return shape (per-class first-seen-at, peak counts), which helps contextualize the 'topN' parameter. However, it does not elaborate further on the parameters beyond their schema descriptions. With full schema coverage, this is a baseline score.

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 it parses the 'leaks' schema from a .trace recorded with a Leaks template, distinguishes it from the leaks(1) CLI snapshot by emphasizing it's a time series, and specifies the exact outputs (per-class first-seen-at timestamp, peak instance count, peak bytes, event count). This makes the purpose unambiguous and distinguishes it from sibling tools like analyzeAbandonedMemory or detectLeaksInXCTest.

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 contrasts this tool with the leaks(1) CLI snapshot and provides a concrete use case: answering 'when in the timeline did the leak appear?' which the snapshot cannot. However, it does not explicitly state when not to use this tool or compare it to sibling tools within the same suite (e.g., analyzeMemgraph), but the context is sufficient for an AI agent to infer appropriate usage.

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. It discloses the use of `leaks(1)`, the output structure, pipeline steps, and behavior of parameters like `fullChains` and `referenceTreeTopN`. However, it doesn't explicitly state that the tool is non-destructive or any authorization requirements, though the nature of the tool implies safety.

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 concise and well-structured: it starts with the main purpose, then details the pipeline, and finally explains parameters. Every sentence adds value without repetition, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity with 6 parameters and no output schema, the description provides a thorough explanation of the output (header, totals, ROOT CYCLE blocks, diagnosis) and the pipeline. It also mentions `suggestedNextCalls`, ensuring the agent can chain tools effectively.

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%, but the description adds significant context beyond the schema. It explains the purpose of each parameter, such as what `fullChains` does, the meaning of `verbosity` levels, the function of `maxClassesInChain`, and the `outputFormat` options. This added value justifies a high score.

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

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

The description clearly states the tool runs `leaks(1)` against a `.memgraph` file and returns a structured summary, specifying the verb, resource, and output format. It distinguishes from siblings like `analyzeAbandonedMemory` by focusing on memory graph debugging.

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 explains when to use the tool (for analyzing .memgraph files) and outlines the pipeline with `classifyCycle` and `reachableFromCycle`, including `suggestedNextCalls` for chaining. It could be more explicit about when not to use it versus alternatives, but the context of sibling tools provides sufficient 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, description carries burden. It describes outputs and version info but omits side effects, authentication needs, or read-only nature. Adequate but not explicit.

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?

Four sentences, each providing distinct value. Front-loaded with specific verb and resource, no 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 no output schema, description covers key return values and dependencies. Missing error handling or prerequisites beyond trace path, but sufficient for typical use.

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% with detailed parameter descriptions. Description adds context about trace template requirements and outputFormat defaults, but doesn't significantly exceed schema info.

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 clearly states the tool parses memory-footprint schema from .trace files, returning specific metrics (peak resident, dirty, VM regions, timeline), and distinguishes from sibling tool analyzeAllocations.

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

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

Explicitly says when to use ('why is my app getting jetsam-killed?') and distinguishes from analyzeAllocations. Lacks explicit 'when not to use' or conditions where other tools would be more appropriate.

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?

The description discloses aggregation logic, raw binaryUUID+offset inclusion, localized-string handling, and limitations (no symbolication, simulator limitation). However, it does not explicitly state that the tool is read-only or has no side effects. With no annotations, this is a minor 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 relatively long but well-structured, with each sentence providing useful context. A minor reduction could improve conciseness, but it remains effective 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?

The description covers input parameters, output structure (three sections, raw binaryUUID+offset, cross-tool hints), and limitations. It does not detail error handling or invalid payloads, but given the complexity, it provides sufficient completeness for effective use.

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 covers all 5 parameters (100% coverage). The description adds significant value by explaining the behavior of each parameter, such as the precedence rule for payloadJson over payloadPath, aggregation behavior of payloadDir, and detailed explanation of groupBy enum options with clustering criteria.

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

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

The description clearly states the tool parses Apple MetricKit .mxdiagnostic payloads from production builds, aggregates crashes, hang hotspots, CPU exceptions, and disk-write exceptions, and returns three actionable sections with cross-tool chaining hints. It distinguishes from sibling tools like analyzeHangs and findCycles by providing specific hints on when to use 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 explicitly states that simulator does not generate MetricKit payloads, so it should be framed as post-mortem analysis. It also clarifies that symbolication is a separate tool and provides cross-tool chaining hints, guiding the agent on when to use this tool versus others.

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

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

With no annotations, the description carries the full behavioral burden. It explains the tool parses a specific schema, returns per-request data and aggregates, and notes version requirements. This sets accurate expectations for the tool's 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?

The description is a single paragraph but packs significant detail without redundancy. Each sentence contributes meaning, though it could be slightly more 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?

Given no output schema, the description covers input requirements, processing, and output structure (per-request details, aggregates). It explains version constraints and parameter functions. However, it lacks differentiation from sibling tools.

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 provides full coverage (100%) and descriptions for all 4 parameters. The description adds context about the trace template and version (v1.14+), enhancing understanding beyond 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?

The description clearly states it parses network trace data, returns per-request details (URL, method, etc.), and provides top-N rankings and per-host aggregates. It specifically names the trace template and schema, distinguishing it from sibling 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 implies use when analyzing network activity from a trace, but lacks explicit guidance on when to use this tool versus other analysis tools (e.g., analyzeTimeProfile). No when-not-to or alternative suggestions.

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?

Discloses that heavy/unsymbolicated traces may crash and describes the returned notice field with workarounds. With no annotations, this provides useful behavioral context, though permissions or other side effects are omitted.

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 concise sentences: the first states the core operation, the second provides a critical caveat. No unnecessary words.

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?

Lacks a description of the normal return structure beyond 'top symbols by sample count'. Without an output schema, more detail on the response format would improve completeness.

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 covers 100% of parameters with descriptions. The first sentence reinforces the meaning of topN, but adds minimal new meaning 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 explicitly states the action (export time-profile schema and return top symbols) and the resource (.trace bundle). It distinguishes from sibling tools by focusing on time-profile analysis.

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

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

No explicit guidance on when to use this tool versus alternatives like analyzeMemgraph. The context is implied but not comparative.

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 fully carries the burden. It discloses all key behaviors: optional build, simulator boot, app install and launch with environment variable propagation, auto-discovery of build settings, and the returned data. No contradictions or omissions are apparent.

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 dense paragraph that front-loads the purpose. It is relatively concise for a complex tool with 11 parameters, though it could benefit from bullet points or clearer separation of logical sections to aid readability. No extraneous information is present.

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 complexity (11 parameters, nested objects, no output schema), the description adequately covers return values (host PID, simulator UDID, bundle ID) and explains how the tool chains into `captureMemgraph`. It also mentions auto-discovery, fulfilling the contextual needs for an agent to use it effectively.

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 covers 100% of parameters with descriptions. The description adds extra meaning for several parameters, such as the default `MallocStackLogging=1` for `envVars` and the conditional use of `buildBeforeLaunch`. This goes beyond the schema alone, justifying a score above 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 description clearly states what the tool does: orchestrates build, boot, install, and launch of an iOS app with MallocStackLogging=1 for leak investigation. It specifies the verb 'orchestration' and the resource 'iOS app', distinguishing it from sibling tools that analyze leaks rather than prepare the environment.

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 explains why this tool is needed (regression in `leaks --outputGraph` on macOS 26.x) and that it is a prerequisite for `captureMemgraph`. It provides context on when to use it, but does not explicitly state when not to use it or mention alternatives among siblings.

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

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

Describes the underlying command (leaks), resolution via pgrep, and the write action. Lacks details on side effects (e.g., process pause) or error handling, but with no annotations, this is a solid 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?

Single concise paragraph front-loading purpose and key mechanics. Every sentence adds value; no 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 no output schema and no annotations, the description fully covers purpose, parameter usage, constraints, and limitations. Provides complete guidance for an agent.

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 already documents all 3 parameters with 100% coverage. Description adds valuable context: mutual exclusivity of pid and appName, resolution via pgrep, and implicit output extension requirement.

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?

Clearly states it captures a .memgraph from a running process using `leaks --outputGraph`. Distinguishes from sibling tools like analyzeMemgraph or diffMemgraphs by focusing on capture.

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

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

Explicitly notes it only works on local Mac and iOS simulator, not physical devices, and directs users to Xcode's Memory Graph button for that case. Provides clear when-to-use/when-not-to-use 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. It discloses that sub-captures are best-effort (if one fails, others still complete) and that a workaroundNotice is surfaced. It also notes required parameters, offering solid transparency for a composite 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?

The description is a single, well-structured paragraph that front-loads the core function and important constraints. Every sentence adds value 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 tool's complexity (multiple outputs, best-effort behavior, chaining with other tools), the description adequately covers the purpose, required inputs, and workflow context. No output schema is provided, but the description implicitly describes the output artifacts.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context like using 'before'/'after' for label and the best-effort behavior, but does not significantly extend the meaning beyond the schema's descriptions.

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

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

The description clearly states the tool is a composite snapshot that writes three artifact types (.memgraph, .png, .ui.json) prefixed by a label. It differentiates from siblings like 'captureMemgraph' (which only captures memgraph) by specifying the multi-artifact nature and its role in before/after flows.

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 it is 'designed to bracket a fix or a replayScenario call' and to 'chain into diffMemgraphs', providing clear usage context. However, it does not explicitly state when not to use this tool or list 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 must disclose behavioral traits. It only states what the tool returns and its pipeline role, but does not mention whether it is read-only, destructive, or requires specific permissions. For a mutation-like analysis tool, this is a 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 two paragraphs: first defines functionality, second guides pipeline usage. It is efficient but contains jargon; a slightly more structured format could improve clarity.

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

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

The description lists return fields and pipeline connections, compensating for the lack of output schema. However, it does not detail the structure of the return values beyond names, which may be sufficient given the 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?

The input schema covers 100% of parameters with descriptions. The description adds no extra parameter information beyond listing return fields, so it meets the baseline but does not exceed it.

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

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

The description clearly states the tool matches each ROOT CYCLE against a catalog of 8 known antipatterns, using specific verbs like 'Match' and 'Returns'. It distinguishes itself from sibling tools like findCycles by focusing on classification against patterns, not just cycle detection.

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 explicit instructions on what to do after using the tool ('follow suggestedNextCalls') and hints at a pipeline context. However, it does not specify when not to use this tool or directly compare to alternatives among the many siblings.

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

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

With no annotations provided, the description carries the full burden. It clearly states the tool's safe default (dryRun true), its destructive nature when dryRun false, scope restrictions, recursion boundary, and the condition for external cleanup. It could mention error handling or output on failure, but it already covers the key behavioral traits.

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

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

The description is structured with clear sections (default-safe, scope, recursion boundary, usage) and front-loaded with a summary. While slightly verbose, each sentence contributes necessary context, and there is no redundant 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?

The description explains the output includes candidates with path, sizeMB, and ageDays, and mentions ok: false for failures. However, it does not provide a complete picture of the response format, such as whether the list is ordered, or the exact structure of success/failure responses. Given no output schema, more explicit output documentation would improve completeness.

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% description coverage, but the description adds significant value beyond the schema: it explains the safety rationale for dryRun default, the env var requirement for root, and the recursion boundary. This enriches the agent's understanding of parameter interactions.

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 title and description clearly state the tool's purpose: previewing and deleting .trace bundles under TRACE_ROOT. The verb 'cleanup' combined with 'Preview and delete' is specific and distinct from sibling tools which focus on analysis or capture.

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 explicit guidance on when to use the tool, including the safe default (dryRun: true), the need for user review before actual deletion, scope restrictions, and the env var requirement for external paths. It also mentions the olderThanDays filter to limit scope.

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

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

With no annotations, the description carries the full burden. It discloses default thresholds, PASS conditions per category, and the verdict output. It does not state whether it is read-only or destructive, but the comparison nature suggests no side effects. No contradictions.

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 paragraphs with key information front-loaded. It is fairly concise but includes some redundant detail (e.g., repeating thresholds). Still, it earns its keep.

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 6 parameters, no output schema, and many sibling tools, the description covers purpose, usage, thresholds, and pipeline adequately. It could be more explicit about the output format but is 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?

Schema coverage is 83%, but the description adds meaning beyond schema by explaining default values, condition for PASS, and how category affects parsing. It also clarifies the pipeline context (e.g., absolute paths).

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 explicitly states it compares two .trace bundles for a specific perf category and emits a PASS/PARTIAL/FAIL verdict, distinguishing it from siblings like verifyFix. The verb 'compares' and resource '.trace bundles' are specific.

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: it is the natural followup to a fix PR, and mentions the pipeline of capturing traces first. It does not explicitly exclude alternative tools but implies its role relative to verifyFix.

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

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

Annotations are absent, so the description must carry full behavioral disclosure. It only states 'count instances' and mentions parameter behavior in passing but does not explain that the tool is read-only, return format, side effects, or permissions. The detailed versioning notes are in the schema, not the description.

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: first defines purpose, second covers usage modes and a concrete use case. Concise and front-loaded with no wasted words.

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 high schema coverage, the description omits contextual details like output structure, error scenarios, or deeper explanation of 'leaked nodes'. For a tool with 9 parameters in a complex domain, more context is needed beyond the schema descriptions.

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 baseline is 3. The description references className and topN but adds little beyond the schema. No contradiction with 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 states the tool counts class appearances in leaked nodes of a .memgraph file, with specific modes for single class or top N. It includes a use case ('confirm whether a fix actually reduced instance counts') and distinguishes from siblings by focusing on class counts in leaked memory.

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 explicit usage guidance: provide className for a single count or omit for top N, and use to verify fix effectiveness. However, it does not discuss alternatives or when not to use this tool, limiting full guideline completeness.

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 fully discloses the tool's behavior: it builds for testing, launches with optional filter, polls for runner process, captures two memgraphs, diffs them, and returns false on new root cycles. It also details edge cases (early runner exit, allowlistPatterns, exit codes) and explains the processName parameter for app-hosted test bundles.

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 well-structured and front-loaded with the sibling relationship and target. Every sentence contributes value, though it is somewhat lengthy. It could be slightly more concise, but overall it efficiently conveys 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?

Despite lacking an output schema, the description explains the return behavior (passed: false, failureReason, htmlReportPath) and exit code. It covers edge cases, per-test granularity, and caller responsibilities. Given the tool's complexity (11 parameters, many behavioral nuances), the description 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 description coverage is 100%, so the baseline is 3. The description does not add substantial new meaning beyond the schema descriptions; it contextualizes testCaseFilter for per-test usage and mentions processName customization, but these are already covered in the schema. No parameters lack explanation.

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 it runs XCTest unit-test bundles with leak detection, identifies itself as a sibling to detectLeaksInXCUITest, and explains the process (build, launch, capture memgraphs, diff). It distinguishes itself by targeting XCTest unit-test schemes rather than UI tests.

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 usage context: designed for CI gating, per-test granularity via testCaseFilter, aggregation responsibility on caller, and notes about fast unit tests with early runner exit. While it doesn't explicitly list when not to use or provide alternatives beyond the sibling mention, the guidance is sufficient for effective use.

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 effectively discloses key behaviors: building, launching, capturing baseline/after memgraphs, diffing, and returning pass/fail based on new root cycle blocks. It also explains the allowlist mechanism and CI gating exit code. Some side effects (like temp files in outputDir) are implicit but clear enough.

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 focused paragraph, immediately front-loaded with the CI tag. Every sentence adds value: it covers build, capture, diff, fail condition, allowlist usage, and exit code. No wasted words.

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?

Although there is no output schema, the description explains return behavior ('passed: false' on failure, non-zero exit code) and mentions the optional htmlReportPath field. It does not explicitly describe the success return value or other response fields, but for a 9-parameter tool this is adequate.

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% with good parameter descriptions. The tool description adds high-level context (e.g., why appName is needed for pgrep, what allowlistPatterns do) but does not go beyond the schema's own descriptions substantially. 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 states the tool runs an XCUITest with leak detection, capturing two memgraphs and diffing them. It distinguishes from siblings like 'detectLeaksInXCTest' (which likely targets XCTest) and other analyze tools by specifying XCUITest+CI gating.

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 'Designed for CI gating: non-zero exit code on failure', implying usage in CI pipelines. However, it does not mention when not to use this tool or suggest alternatives like other memory analysis tools for non-test scenarios.

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, description should disclose behavior. It doesn't explicitly state it's read-only or handle errors, but the term 'compare' implies non-destructive. Lacks details on file requirements or side effects.

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 front-loaded sentences convey purpose, outputs, and use case without unnecessary words. Efficient and structured.

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?

Explains return values (deltas, class changes, root cycles) adequately despite no output schema. Could be slightly more detailed about data structures, but sufficient for agent selection.

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?

All parameters are fully described in the schema (100% coverage). The description adds no additional explanation beyond what the schema provides, so baseline 3 applies.

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

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

The description clearly states it compares two .memgraph files and lists specific outputs (deltas, class changes, root cycles). It uniquely distinguishes from siblings by focusing on diffs, especially for verifying fixes.

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?

Implicitly indicates use when comparing baseline vs comparison snapshots, especially for fix verification. Lacks explicit when-not or alternatives, but context 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?

The description explains the output format and filtering capability. It implies a non-destructive analysis. Without annotations, the description carries the full burden, and it adequately covers the tool's behavior, though it could mention that it only reads files and does not modify them.

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, front-loaded with the core function, and efficient. Every sentence adds value 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?

Despite no output schema, the description specifies the output format (flattened chains with fields) and mentions optional filtering and depth truncation. It could be more explicit about the return type (e.g., array), but it is fairly complete for a file-reading analysis 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 coverage is 100%, so baseline is 3. The description adds context for the className parameter (substring match) and the verbosity parameter implicitly, but does not significantly extend understanding 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 states it extracts ROOT CYCLE blocks from a .memgraph as flattened chains with specific fields (depth, edge, retainKind, className, address). It also mentions optional filtering by class name, distinguishing it from analyzing all leaks.

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 'Use this when you want to inspect chains without the noise of standalone leaks,' providing a clear use case. However, it does not name specific alternative tools or state when not to use it.

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

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

No annotations are provided, so the description carries full burden. It details the includeReferenceTree parameter, including prerequisites (MallocStackLogging) and behavior changes. It does not mention side effects or resource usage, but overall discloses key behavioral aspects.

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 concise with two main sentences and a detailed note for includeReferenceTree. The note is necessary but somewhat lengthy. Overall efficient with no wasted words.

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

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

No output schema exists, but the description states what is returned ('paths from a top-level node down to the matching node'). It covers the main behavior and the advanced parameter, though it could benefit from more examples or edge cases.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds significant context for includeReferenceTree, but for other parameters (path, className, maxResults) it adds minimal value beyond the schema descriptions.

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 specific verb 'walk' and resource 'retain chains', clearly stating it finds retain chains for a class name substring. It distinguishes itself from siblings like findCycles and analyzeMemgraph by focusing on retainers of a specific class.

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 mentions it is 'useful for answering who is keeping <class> alive?', implying when to use, but does not explicitly state when not to use or provide alternatives. Sibling tools are not contrasted.

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 provided, so description must carry full burden. It describes the return and usage but does not explicitly state it is read-only or non-destructive, nor mention any side effects.

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, each earning its place: first defines the tool, second gives usage guidance. Information is front-loaded and efficient.

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 absence of an output schema, the description mentions the structure of each step (tool name, purpose, argsTemplate). This provides adequate completeness for a meta-tool, though a bit more detail on format could be added.

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 of the 'kind' parameter adds valuable context beyond the schema, such as the most common flow and its purpose. Schema coverage is 100% and the description enhances 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?

Clearly states it returns a versioned, declarative pipeline for known investigation flows, with specific examples. Distinguishes itself from sibling analysis tools by being a meta-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?

Explicitly advises to use it once at the start of an investigation to avoid rediscovery of the tool sequence. Provides a clear context for when to invoke.

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?

Discloses that it runs 'xcrun xctrace export' and returns specific fields like schemas, device info, and suggestedNextCalls. Also describes fallback and empty trace behavior. Since no annotations are provided, the description carries the full burden and does so well.

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 main purpose and usage guidance, and covers fallback and return details efficiently. It is slightly verbose but every sentence adds value.

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 output schema and many sibling analyzers, the description is exceptionally complete. It explains the return format (schemas, row counts, device, OS, etc.), includes a suggestedNextCalls array to guide tool selection, and addresses empty traces and fallback behavior.

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

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

The single parameter 'tracePath' has a description in the schema that is already clear. The description adds minor context (e.g., 'output of xcrun xctrace record or Instruments'), but with 100% schema coverage, the value added is limited, warranting a baseline of 3.

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

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

The description clearly states the tool is an orientation tool for .trace bundles, listing specific outputs like schemas, row counts, and suggested analyzers. It distinguishes itself from sibling analyzers by positioning itself as the first call to avoid blindly chaining analyzers.

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

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

Explicitly recommends using this as the first call when handed a .trace, and describes a fallback path for older xctrace versions. However, it does not explicitly state when not to use it or provide alternatives for other scenarios.

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

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

With no annotations, the description carries the full burden. It explains it runs a shell command and parses output, and describes the parameter behavior. However, it does not disclose potential side effects, required permissions, or return format details, which are typical for a list 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?

The description is two sentences with an additional sentence for the parameter, all front-loaded with the main action. No unnecessary words or 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 tool's simplicity (1 param, no output schema, no nested objects), the description covers the essential aspects: what it does, when to use it, and a parameter detail. It could mention the output format but is adequate overall.

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% with one parameter described. The description adds the term 'disconnected devices' as a synonym for 'Devices Offline', but this is marginal improvement over the schema's existing description. Baseline 3 applies.

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

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

The description clearly states the tool runs 'xcrun xctrace list devices' and returns parsed devices/simulators with UDIDs, which is a specific verb+resource. It distinguishes itself from siblings by being the pre-requisite for recordTimeProfile and for device discovery.

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 LLM to call this before recordTimeProfile to discover the right UDID without asking the user, providing clear when-to-use context. It also explains the includeOffline parameter but does not explicitly mention when not to use the 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?

No annotations provided; description reveals it executes an external command and returns parsed templates. Provides transparency about the operation and output type.

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 concise sentences: first states action and output, second gives usage context with examples. No unnecessary words.

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 parameters and no output schema, description fully covers purpose and usage context. No gaps for an agent to understand.

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?

No parameters, schema coverage 100%. Baseline for 0 params is 4; description adds no param info needed.

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?

Clearly states it runs 'xcrun xctrace list templates' and returns parsed standard + custom templates. Distinguishes itself as the tool to list templates, unlike sibling analysis 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?

Explicitly says 'Useful when picking a template name for recordTimeProfile' with examples. Does not mention when not to use or alternatives, but context is clear.

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 discloses that it wraps log show (a read operation), returns parsed entries with specific fields, and bounds output by maxEntries. It explains the sugar for process and subsystem filters.

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 and a tag, front-loading the core purpose. Every sentence adds value with no waste.

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 six parameters (all documented in schema), no output schema, and 100% schema coverage, the description explains the output format (parsed entries with fields) and bounding. It is complete for a one-shot query 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 coverage is 100%, so baseline is 3. The description adds significant meaning: explains the sugar for process and subsystem over predicate, describes the level enum as minimum log level, and clarifies maxEntries as a cap on parsed entries.

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 it queries macOS unified logging one-shot, wrapping log show with filters and sugar. It distinguishes from sibling tools like logStream (streaming) by using 'one-shot' in the title and describes the parsed output.

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 says 'Use this to look back at app logs without leaving chat,' implying a one-shot query scenario. It does not explicitly mention when not to use or contrast with alternatives like logStream, but the context implies it.

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

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

No annotations are provided, so the description carries the burden. It discloses the underlying command, bounded duration (≤60s), and that it returns parsed entries. However, it does not describe error handling, destructive potential, or other behavioral traits beyond the basic 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?

The description is concise at three sentences, front-loaded with the core purpose. It could benefit from a more structured breakdown of parameters and usage.

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 6 parameters and no output schema, the description is incomplete. It lacks details on return format, parameter semantics beyond duration, and how to interpret parsed entries. The absence of annotations exacerbates the gaps.

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

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

The input schema has 6 parameters with only 17% description coverage (only durationSec has a description). The description adds minimal meaning beyond the schema, mainly repeating the duration constraint and default. It does not explain predicate, process, subsystem, level, or maxEntries.

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 it wraps `log stream --style compact` for a bounded duration, returns parsed entries, and is useful for capturing a specific user flow. It effectively distinguishes itself from sibling tools like logShow and other analysis 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 implies usage for capturing user flows without setting up Console.app, but lacks explicit guidance on when not to use or alternatives. It does not mention contexts where it might be inappropriate or provide 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?

No annotations provided, so description carries full burden. It details the return format (per-class counts, total reachable node count) and explains default behavior for cycleIndex. Does not mention potential errors or side effects, but for a read-only analysis tool this is acceptable.

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?

Description is front-loaded with purpose and includes a concrete example. It is slightly verbose but each sentence adds value. Could be streamlined, but overall well-structured.

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 output schema and six parameters, description adequately explains output and parameter usage. It covers the primary use case and parameter interplay. Lacks error handling details, but that is secondary for this 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 baseline is 3. Description adds some value beyond schema (e.g., output format, cycleIndex default), but does not significantly enhance understanding of individual parameters beyond what the schema already provides.

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 '[mg.memory] Cycle-scoped reachability + class counting' and provides a concrete example ('how many NSURLSessionConfiguration instances are reachable from the cycle rooted at DetailViewModel?'). It clearly identifies the tool's function and distinguishes it from sibling tools by focusing on cycle-root scoped reachability rather than general leak analysis.

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?

Description explains how to select a cycle via cycleIndex or rootClassName, and gives a concrete question the tool answers. It lacks explicit when-not-to-use or alternative tool mentions, but the guidance is sufficient for the intended use case.

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 provided, so description carries full burden. Describes that it records a trace, specifies default template and duration, and output path constraint. Lacks mention of side effects like file creation or potential wait time, but adequate for a capture 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 clear structure and front-loaded key information. Every sentence adds value.

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?

Covers all essential aspects: recording purpose, required parameter groups, defaults, and output constraint. No explanation of return value, but file-based output is implied. Good for an agent to invoke 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 description adds mutual exclusivity rules and output path format, which go beyond individual parameter descriptions.

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?

Clearly states it captures a .trace bundle using xcrun xctrace record, specifying it wraps the underlying command. Distinguishes from sibling tools like recordViaInstrumentsApp.

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

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

Explicitly lists required parameter combinations (exactly one of deviceId/simulatorId, etc.) and defaults. Not explicit about when not to use, but context with sibling tools makes usage clear.

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?

The description mentions user-in-loop step, polling, timeout, and chained inspectTrace summary, but lacks details on error handling, side effects (e.g., leftover files), or blocking nature. With no annotations, the description carries full burden and provides adequate but not comprehensive transparency.

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?

Four sentences efficiently cover action, rationale, return values, and timeout. The title provides additional context. Could be slightly more concise (e.g., remove version number), but overall well-structured and 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 the complexity of a tool requiring user interaction, polling, and chaining, the description sufficiently explains the return structure (instructions, tracePath, inspectTrace summary) and timeout. Missing output schema is compensated. No mention of error states or termination beyond timeout.

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% with detailed descriptions for each parameter. The description adds minimal value beyond schema, only repeating the timeout default and mentioning the chaining behavior. Baseline 3 is appropriate as schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: open Instruments.app, prompt user to record/save a .trace, poll watchDir for new bundle, and chain into inspectTrace. It explicitly distinguishes from sibling recordTimeProfile by framing it as a macOS 26.x workaround for the failing xcrun xctrace record.

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 context for when to use (macOS 26.x escape hatch) and chaining into inspectTrace, but does not explicitly state when not to use or name alternatives beyond xcrun xctrace record. Sibling list includes recordTimeProfile, but no comparative 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?

No annotations are provided, so the description carries the full burden. It discloses that app-level classes are highlighted and cycle-back terminators are styled distinctly, but does not cover error behavior or side effects such as file reading failures.

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 concise with three sentences. The first sentence captures the main action, the second adds styling details, and the third provides a usage tip. No unnecessary words, and it 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?

The description explains output format options and styling, and combined with the schema, covers the tool's functionality. However, it lacks details on return values or error handling, but for a rendering tool, it is adequate.

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

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

Schema description coverage is 100%, so the schema documents all parameters. The description adds context beyond the schema by mentioning styling details and usage hint for cycleIndex, providing moderate additional 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 description clearly states the tool renders a retain cycle as a Mermaid or DOT graph from a .memgraph file, specifying the verb 'render' and resource 'retain cycle'. It differentiates from sibling tools like findCycles by focusing on graphical output.

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 explicit usage guidance by mentioning the use of cycleIndex to render cycles other than the first. It does not explicitly state when not to use or compare to alternatives, but the context is clear for rendering tasks.

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 disclosure burden. It reveals repetition behavior, screenshot capture behavior (v1.15+, non-fatal failures), axe dependency handling via workaroundNotice, and pairing with captureScenarioState. Could mention what happens if elements are not found in UI.

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 well-structured with a clear purpose statement upfront, followed by key details in 4-5 sentences. Each sentence contributes unique information without repetition, maintaining excellent conciseness.

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 6 parameters, no output schema, and moderate complexity, the description covers main workflow, dependencies, and usage patterns. It lacks detailed error handling for individual actions but is otherwise complete for the 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 100%, so baseline is 3. The description adds value by providing usage hints (e.g., 'repeat 5-10 to amplify leaks', 'increase settleBetweenActionsMs for animation-heavy flows') and explaining behavior of screenshotDir and finalUITreePath, going beyond schema descriptions.

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

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

The description clearly states the tool drives a sequence of UI actions (tap, swipe, wait, type) and repeats them to amplify leaks. It distinguishes from siblings like captureScenarioState and ties to the verify-fix workflow, using specific verbs and resource context.

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 explains when to use the tool (amplify leaks in verify-fix loops) and recommends pairing with captureScenarioState. It mentions a soft dependency on `axe` and provides workaround. However, it lacks explicit 'when not to use' instructions compared to 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 must disclose behavior fully. It explains chaining of tools, output composition (structured result + markdown card), handling of empty schemas and analyzer failures, and the impact of verbose/focus parameters. It does not discuss performance or authorization, but covers key behavioral traits.

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

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

The description is compact yet comprehensive, starting with a concise summary and then detailing usage, output, and parameter effects. Every sentence adds value, though it could be slightly more concise without losing 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?

Given the tool's complexity (chaining multiple analyzers), the absence of annotations and output schema, the description is remarkably complete. It explains the output format (headline, per-area sections, suggestedNextCalls), parameter effects, and edge cases (analyzer failures), fully compensating for missing metadata.

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% (all three parameters have descriptions). The description adds value by clarifying tracePath ('absolute path'), focus ('emphasizes that area'), and verbose ('card size trade-off'), going beyond the schema's basic descriptions.

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 'summarize' and resource '.trace bundle', and clearly distinguishes from siblings by describing it as a single-call synthesis that chains multiple analyzers, contrasting with individual analyzer 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?

Explicitly advises using as the first call for a synthesis pass instead of manually chaining analyzers, and describes parameter effects. However, it could more explicitly state when not to use it (e.g., for raw data from a specific analyzer).

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 fully discloses the mechanism (SourceKit-LSP, regex pre-scan), the requirement for an index store, and the output behavior including the 'needsIndex' hint. It is complete and transparent.

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 purpose and uses a clear structure, but it is slightly verbose with code blocks and extra detail. Still efficient for the information conveyed.

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 complexity (4 params, no output schema), the description covers the output format (snippet per line, hint) and requirements. Could be more explicit about the exact output structure, but sufficient for an agent.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining how filePath is used for locating the declaration and the default discovery for projectRoot, going beyond the schema descriptions.

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 it finds every reference to a Swift symbol, using the verb 'find' and resource 'Swift symbol references'. It distinguishes from sibling tools like swiftGetSymbolDefinition by focusing on all references across the project.

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 explains the prerequisite of an IndexStoreDB and how to build it, but does not explicitly exclude alternatives or specify when not to use it compared to sibling tools. The context is clear for typical usage.

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

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

With no annotations, the description carries the full burden. It describes the output (markdown/plaintext hover content and declaration fragment) but does not disclose behavioral traits such as read-only nature, error handling, or performance characteristics. The 'best-effort' qualifier adds some transparency but is insufficient.

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 extremely concise: two sentences that immediately convey the technical identity and a practical use case. Every sentence earns its place without fluff.

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 lacking an output schema, the description explains what is returned (markdown/plaintext hover content and declaration fragment). It also gives a concrete usage context. However, it could be more detailed about the return structure or potential failure cases, which prevents a perfect score.

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

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

The description does not add any meaning beyond the input schema. Schema coverage is 75% (projectRoot lacks description), and the description does not clarify that parameter or provide additional context for other parameters. The description adds zero value for 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 clearly states it performs a SourceKit-LSP textDocument/hover request at a specific position, which is a specific verb+resource. It distinguishes from sibling tools like swiftGetSymbolDefinition by focusing on hover content and type info, not definitions.

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 a explicit use case: disambiguating self captures in closures. However, it does not mention when not to use it or suggest alternatives, which prevents a higher score.

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?

Without annotations, the description fully discloses behavior: pre-scans with regex, uses SourceKit-LSP, returns position even if LSP fails. This gives the agent a clear model of how the tool operates.

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 concise sentences plus a usage note. Every sentence earns its place: first states purpose and algorithm, second provides workflow context. No redundant 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?

Given 4 params, nested object, and no output schema, the description covers the algorithm, fallback, and typical use case. Lacks explicit return format (e.g., file path and line number), but 'Returns the position' is adequate. Complete enough for the 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 coverage is 100%, baseline 3. Description adds meaning for all parameters: explains symbolName types, hint usage, projectRoot override, and candidatePaths as a speedup. Exceeds baseline by explaining the two-step search process.

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?

Clearly states it finds the file:line where a Swift symbol is declared, using specific verb-resource pairs. Distinguishes from siblings like swiftFindSymbolReferences by mentioning typical use after findRetainers/classifyCycle.

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

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

Explicitly says to use after findRetainers/classifyCycle to land in source file. Provides guidance on candidatePaths and hint to speed up search. Does not list alternative tools for different purposes, but implies context.

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

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

Describes as 'cheap orientation' via SourceKit-LSP's documentSymbol, implying a read-only, lightweight operation. No annotations to contradict; clear enough for agent to infer safety.

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 concise sentences, front-loaded with purpose and key parameter guidance. No redundant or irrelevant 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?

Covers purpose and usage context well, but lacks description of return format (symbol structure) despite no output schema. Relies on prior knowledge of documentSymbol output.

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?

Adds value for topLevelOnly by explaining its effect and default behavior. But projectRoot lacks description in both schema and tool description, and filePath is covered identically in 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?

Description clearly states verb (returns), resource (top-level symbols in Swift file), and distinguishes from sibling swiftGetSymbolDefinition by noting it gives orientation after landing in a new file.

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

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

Explicitly suggests using after swiftGetSymbolDefinition for quick orientation, and hints at topLevelOnly parameter adjustment. Does not exclude other cases or compare with other swift 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 full burden. It discloses that the tool does not use SourceKit-LSP or IndexStoreDB, is a pure regex search, and returns positional data with snippets. It could mention that it is read-only with no side effects, but the current detail is sufficient for safe invocation.

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, well-structured paragraph. The first sentence immediately states the core functionality and constraints. Every subsequent sentence adds meaningful context (what it catches, return format) without unnecessary words.

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 moderate complexity and absence of an output schema, the description adequately covers purpose, usage, and return format. It could address edge cases like invalid regex or missing file, but overall it is complete enough for effective use.

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%, but the description adds value beyond schema descriptions. It explicitly notes the regex is JavaScript flavor with an implied 'g' flag, and suggests patterns for leak hunting. These details help the agent craft effective queries.

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 it performs pure regex search over a Swift file's contents, distinguishing it from LSP-based tools. Specific examples (closure capture lists, Task blocks) make the purpose unmistakable and differentiate it from sibling tools like swiftFindSymbolReferences.

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

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

The description implies when to use the tool—'Catches what LSP misses'—and provides concrete patterns from leak investigations. While it does not explicitly list when not to use or name alternatives, the context is strong enough for an AI agent to infer appropriate scenarios.

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 provided, so description carries full burden. It discloses the tool emits a 'per-pattern PASS/PARTIAL/FAIL verdict plus bytes freed and instances released', and explains conditional behavior with expectedPatternId. However, it does not mention any error conditions, permissions, or side effects, which is minor for a likely read-only diff 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?

The description is only three sentences, front-loading the core function with a domain tag. Every sentence provides essential information: what it does, output, usage as CI gate, and pipeline context. No wasted words.

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

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

No output schema exists, but the description covers the main output elements (verdict, bytes freed, instances released). It also explains the pipeline placement. It could be more explicit about the exact structure of the output, but it is sufficient for typical use.

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 high (83%), so baseline is 3. The description adds context about expectedPatternId producing a verdict field, but this concerns output rather than input parameter semantics. It does not add meaning beyond the schema's own descriptions for 'before', 'after', or other parameters.

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

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

The description clearly states the tool verifies a fix for a retain cycle, using a 'cycle-semantic diff' and emitting verdicts. It explicitly ties it to the tool 'classifyCycle' as a followup, distinguishing it from sibling tools like 'diffMemgraphs' or 'findCycles'. The verb 'verify' and resource 'fix for retain cycle' are specific.

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 directly says 'Use as a CI gate' and explains the pipeline: 'natural followup to classifyCycle after you've shipped a fix'. This tells the agent exactly when to invoke this tool and what the prior step is, excluding other contexts.

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