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

The description goes far beyond the readOnlyHint annotation by detailing the `mode` values ('real', 'mock', 'unavailable') and their implications. It discloses that mock mode produces fabricated numbers for testing, and that unavailable mode includes fix notes. It also surfaces the CPU-specific limitation, which is crucial behavioral context for downstream tool 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 concise and front-loaded: the first sentence states the purpose, and the following sentences elaborate with essential details about modes and compatibility. Every sentence adds value—no filler or redundant restatement of the tool name. The structure is logical and scannable.

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

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

For a zero-parameter environment probe with an output schema, the description is thorough. It explains the key output fields (mode and available_analyses), provides guidance on when to call it, and includes a hardware caveat. The context signals show high schema coverage and a rich output schema, but the description still adds meaningful context beyond what structured data provides.

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

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

The tool has zero parameters, so the input schema is empty and the description cannot add parameter-specific meaning. Per the rubric, a 0-param tool receives a baseline score of 4, which is appropriate here. The description does mention output fields (`mode`, `available_analyses`) but these are return values, not inputs.

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

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

The description opens with a specific verb ('Probe') and resource ('uProf environment') followed by a clear list of outputs (binary, version, platform, active mode, results dir). This distinguishes it from sibling tools like uprof_collect (collects data) and uprof_report_* (reports on collected data), making its purpose unmistakable.

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

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

The description explicitly says 'Call this before collecting,' establishing it as a prerequisite for collection tools. It also explains that `available_analyses` feeds into uprof_collect and notes a hardware limitation (only 'tbp' works on non-AMD CPUs), which helps an agent decide when and how to use the information. It does not explicitly name alternatives, but the sequencing guidance is clear and actionable.

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 carries the behavioral disclosure burden. It reveals that pid attach requires duration_sec, that timeout can kill the collection (default 300s), that non-zero app_exit_code is surfaced as a warning so crashes aren't mistaken for clean profiles, and that in mock mode the target runs but profile numbers are synthetic. This is rich, useful behavioral detail.

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

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

The description is a single, well-organized paragraph with the main purpose front-loaded. Every sentence adds value, parameter names are neatly backticked, and it avoids redundancy while covering many details. It is appropriately sized for a 10-parameter tool and wastes no 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 complexity (10 parameters, no annotations), the description is remarkably complete. It covers nearly all parameters, explains pitfalls (attach requires duration, only 'tbp' on non-AMD), describes timeout behavior and warning semantics, and tells the agent how to use the result (feed to report/compare tools). The existence of an output schema means return values need not be detailed, making this description 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 description coverage is 0%, so the description must compensate. It does: it explains command, pid, config (including non-AMD restriction and allow_unknown), call_graph, extra_events, label, timeout_sec, duration_sec, and allow_unknown, adding meaning far beyond raw schema. Only working_dir is omitted, but 9/10 parameters are enriched with defaults, constraints, and examples, which is outstanding.

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

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

The description opens with 'Run a uProf collection and store the result; returns a `result_id` handle.' This states a specific verb ('Run') and resource ('uProf collection'), and clearly distinguishes from sibling report/compare tools by producing a result_id for them to consume. It unambiguously answers what the tool does.

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

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

The description gives strong usage context: 'Pass exactly one target: command... or pid', mentions uprof_check for listing configs, and says to feed result_id to report/compare tools. However, it does not explicitly state when NOT to use this tool or name alternative tools ('use uprof_list_results instead'), so it falls short of the most explicit standard.

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 verdict logic: failure when total or significant function regresses beyond threshold_pct, noise floor exclusion, and the fail_on_regression error behavior. This is crucial for automated use.

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

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

The description is three sentences, front-loaded with the core purpose, then context, then behavioral details. Every sentence contributes value 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?

The description fully covers the tool's behavior, parameter semantics, and usage context. An output schema exists, so return values need not be described. It is complete for the tool's 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?

The description adds meaning to all parameters: threshold_pct and noise_floor_pct are explained in the verdict logic, fail_on_regression is described as raising a tool error, and baseline_id/candidate_id are implied by the compare operation. This compensates for the 0% schema coverage.

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 compares two stored results function-by-function and issues a pass/fail verdict. This specific verb+resource distinguishes it from sibling tools like uprof_collect or uprof_report_raw.

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 positions the tool as the core of an optimize loop, explaining when to use it after collecting baseline and candidate. It also explains how to gate automated loops with fail_on_regression, but does not explicitly name alternatives or exclusions.

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

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

Read-only is already declared in annotations, and the description adds the important caveat that entries stamped 'mock' contain synthetic numbers. This tells the agent that some results may not be real data.

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

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

The description is two sentences with no filler. The main action is front-loaded, followed by usage guidance and a data-quality caveat.

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

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

For a parameterless read-only list tool with an output schema, the description covers purpose, usage, and the mock-data caveat. It is fully sufficient for an agent to decide when and how to invoke it.

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

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

The tool has zero parameters, so the schema holds no explanatory burden. The description adds no parameter-specific detail, but none is needed, so the baseline of 4 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 uses the specific verb 'List' and identifies the resource 'stored uProf results' along with the key fields returned. This clearly distinguishes it from sibling reporting and collection tools.

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

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

The description explicitly states 'Use to rediscover result_ids from earlier collections,' providing a clear when-to-use scenario. It doesn't explicitly mention alternatives, but the context is sufficient.

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 the readOnlyHint annotation, the description adds substantial behavioral detail: top_n is clamped to 100, output includes row_count_total and truncated flags, and ignore_system_modules causes a re-run excluding system libraries. This goes well beyond the annotation and helps the agent understand side effects and edge cases.

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

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

The description is three sentences, with the main purpose in the first sentence and supporting details in subsequent sentences. Every sentence adds value: behavior constraints, output flags, and usage recommendation. No filler 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 output schema and the readOnlyHint, the description provides sufficient context. It covers the main behavior, parameter semantics, and even adds output-related context (row_count_total/truncated) that is not required. It offers a recommendation on usage, making it complete for a report 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 0%, so the description must compensate. It explains top_n clamping and ignore_system_modules behavior, and mentions result-related output fields. The result_id parameter is not explicitly described, but its meaning is inferable from 'stored result.' This is strong compensation for the missing 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's function: 'Top-N hottest functions of a stored result, sorted by sample share descending.' It uses a specific resource ('stored result') and distinguishes itself from siblings like uprof_report_summary and uprof_report_raw by focusing on hotspots.

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, such as 'Start with the defaults,' and explains when to use the ignore_system_modules parameter. It does not explicitly mention alternative tools or when not to use this tool, but the purpose itself implies the appropriate scenario.

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?

Beyond the readOnlyHint annotation, the description discloses caching behavior after first use, regeneration into report-raw.csv when extra_args are supplied, and head+tail truncation. It also notes that full data is available via files under result_dir. The mention of `command` is confusing but does not contradict the annotation.

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 compact three-sentence paragraph that front-loads the core purpose in the first sentence. Every sentence adds useful context: the stdout contrast, the extra_args behavior, and the truncation caveat. The unclear `command` sentence is a minor flaw, but overall it's 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?

The description covers the main behavioral aspects: what is returned, how extra_args affects generation, truncation behavior, and where to find full data. Given the presence of an output schema (which likely details the return structure), the description is reasonably complete. It lacks explicit result_id guidance but is sufficient for a raw report 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?

With 0% schema description coverage, the description partially compensates: it explains extra_args as 'raw AMDuProfCLI report options, each starting with "-"' and says they cause regeneration into report-raw.csv. However, result_id is only implicitly defined as a stored result identifier, and the description introduces a non-schema parameter `command`, muddying the semantics.

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

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

The description clearly states it returns 'raw uProf CSV report text for a stored result,' with 'escape hatch' signaling raw output distinct from sibling summary tools. It specifies the resource (stored result) and the action (returns CSV) and differentiates from siblings like uprof_report_summary and uprof_report_hotspots.

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 the tool is an 'escape hatch' for raw CSV, contrasted with uProf's normal stdout behavior. It advises that long output is truncated and full data should be read via files under result_dir, implying when not to rely on this tool. However, it doesn't explicitly name alternative sibling tools for summarized reports.

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?

Beyond the readOnlyHint annotation, the description discloses a meaningful side effect: 'Generates the CSV report on first use (cached in the session dir afterwards).' This tells the agent about the caching behavior and first-use generation, adding insight into what happens when the tool is invoked. There is no contradiction with the annotation.

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

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

Three sentences with no fluff. Front-loaded with the main purpose, followed by the behavioral note and parameter source. 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 the tool's simplicity (one required parameter, output schema present, readOnlyHint annotation), the description covers purpose, usage context, behavior, and parameter origin. No critical gaps remain.

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

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

Schema coverage is 0%, but the sole parameter result_id is explained as coming from uprof_collect or uprof_list_results. This gives the agent a clear source for the parameter value. It doesn't describe format specifics, but for a single parameter derived from other tools, this is sufficient.

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 provides a parsed run overview of a stored result, listing key content (duration, top hotspots, host details). It distinguishes itself from sibling tools by positioning it as the fastest way to understand a collection before drilling into hotspots, clearly separating it from uprof_report_hotspots.

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

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

The description gives clear when-to-use guidance ('The fastest way to understand a collection before drilling into hotspots') and explains where result_id comes from (uprof_collect or uprof_list_results). It does not explicitly name alternatives or exclusions, but the 'before drilling into hotspots' phrase implies the workflow.

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 annotation readOnlyHint=true already establishes the tool is safe, and the description adds context by naming the underlying CLI command and warning that 'in mock mode the fields are synthetic.' This goes beyond the annotation without contradicting it.

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: three short sentences, front-loaded with the core purpose, then usage context, then a caveat. Every sentence adds value, with no redundancy or 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?

Given the tool has zero parameters, an output schema, and a read-only annotation, the description fully covers the necessary context: what data it provides, why to use it, and a note about mock mode. Nothing essential is missing.

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

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

There are no parameters, so the schema trivially covers 100% of them. The description doesn't need to explain parameter meanings; the baseline of 4 applies. It could optionally mention what fields are returned, but that's covered by the output 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 retrieves parsed system information from a specific command ('AMDuProfCLI info --system'), listing concrete data points (CPU model/family, core counts, OS details). This distinguishes it from the sibling tools that focus on collection and reporting.

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

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

The description explicitly says when to use the tool ('to decide which collect configs the hardware supports before profiling'), providing clear context. It doesn't mention alternative tools or exclusion cases, but the guidance is direct and practical for a read-only info tool.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: sampling at a configurable interval (minimum 10), returning summaries (min/max/mean/last) rather than the full series, and the fact that CSV files remain in result_dir. It also clarifies mock mode vs real hardware. This goes well beyond a simple tautology, though it could mention side effects like file writing more explicitly.

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 information-dense. It front-loads the primary action, uses backticks for parameter names, and conveys all key points in a few sentences without redundancy. Every sentence earns its place by adding crucial context (events list, intervals, summaries, hardware requirement).

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

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

Despite the absence of annotations and schema descriptions, the description covers the essential context: what the tool does, parameters, return format (summaries), the location of raw data (result_dir), and environment requirements (AMD hardware vs mock). An output schema exists, so the description does not need to detail return values, but it still explains the semantics. It is complete for a tool of this complexity.

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

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

Schema coverage is 0%, so the description must compensate—and it does thoroughly. It explains that `events` are timechart categories and lists them, states the minimum for `interval_ms` (10), specifies `duration_sec` as the sampling window, and explains `command` as an optional command to run during sampling. Every parameter receives meaningful semantic context beyond the raw schema types.

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 function: 'Sample system power/frequency/thermal counters over time and summarize them.' This is a specific verb+resource (sample/timechart categories) and the scope is distinct from sibling tools like uprof_report_raw or uprof_list_results, which focus on reporting or listing results rather than sampling and summarizing.

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: it is for sampling counters over a time interval and getting summary statistics. It also notes the option to run a command and the hardware prerequisite ('Real data needs AMD hardware'). However, it does not explicitly name alternative tools for when the full series is needed or when other reporting tools are more appropriate, so it lacks explicit exclusions.

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