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

The description correctly indicates a read-only analysis (consistent with readOnlyHint=true). It adds specific return details beyond the annotation, but doesn't disclose potential dependencies or error conditions that might affect agent decisions.

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

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

The description contains two sentences, but the second repeats the first sentence's return value list verbatim. This redundancy wastes space. A single sentence would suffice.

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

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

For a simple tool with no parameters and a read-only action, the description adequately covers the tool's purpose and output despite lacking an output schema. No critical 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?

With no parameters (0 params), the description does not need to add param-specific meaning. The baseline score of 4 is appropriate as the tool's operation is self-explanatory.

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

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

The description clearly states it parses and analyzes makepkg.conf, listing specific return values (CFLAGS, MAKEFLAGS, compression settings, build configuration). The [CONFIG] prefix and contrast with sibling tools (analyze_pacman_conf, analyze_storage) provide differentiation.

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 only usage hint is 'Only works on Arch Linux,' which is a platform constraint. No guidance on when to use this tool versus alternatives like analyze_pacman_conf, nor when it is or is not 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?

Annotations declare readOnlyHint=true, and the description adds behavioral context such as the OS constraint and detailed return content per focus, which goes beyond the annotations.

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

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

The description is concise, front-loaded with purpose, and every sentence adds necessary detail 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?

For a tool with no output schema, the description adequately covers return values per focus. It could mention error handling or behavior on non-Arch systems, but for a simple configuration parser, it is mostly complete.

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

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

The schema covers all parameters, and the description adds significant value by explaining each focus option's return behavior, including warnings for critical ignored packages and optimization recommendations for parallel downloads.

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 and analyzes pacman.conf with optional focus, listing outputs. However, it does not explicitly differentiate from sibling tools like analyze_makepkg_conf, relying on the tool name and 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 indicates it only works on Arch Linux and provides examples for focus options, but it does not explicitly state when to use this tool over alternatives or provide exclusion 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?

Annotations indicate read-only, which description does not contradict. Description adds valuable behavioral details about action scopes (cross-platform vs Arch-specific) beyond 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?

Extremely concise two-sentence description with a [MONITORING] tag for quick identification. No unnecessary words; every piece of information earns its place.

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

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

Given a single required parameter with enum, readOnlyHint annotation, and no output schema, the description provides all necessary context for correct agent invocation, including action-specific constraints.

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 all parameters with enum descriptions. The description enhances meaning by explaining each action's purpose (check disk space, analyze cache), which is not present in 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?

Description clearly states it's a unified storage analysis tool with two specific actions: disk_usage and cache_stats. It is distinct from sibling tools which focus on configuration or package management.

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 context on system compatibility: disk_usage works on any system, cache_stats is Arch-only. This guides appropriate use, though no alternative tools are mentioned.

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

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

Annotations already indicate readOnlyHint=true, so the description adds limited behavioral context. It explains the two actions but does not disclose potential limitations or side effects beyond the read-only nature. No contradiction with annotations.

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

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

The description is concise, with a clear introduction, bullet-like list of actions, examples, and a warning. Each sentence serves a purpose, though the examples could be more streamlined for brevity.

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 functionality and actions but does not explain the output or the optional parameter 'package_info' in detail. With no output schema, more information about return values 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 coverage is 100%, but the description adds value by providing examples and explaining the two actions in context. It clarifies the relationship between action and the optional parameters, which the schema alone does not fully convey.

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: a comprehensive security audit for AUR packages, listing two specific actions. It distinguishes itself from sibling tools by focusing on AUR package security, unlike other audit tools that analyze system configuration or check database freshness.

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 examples and a warning ('Always audit AUR packages before installing'), implying when to use the tool. However, it does not explicitly state when to avoid using it or mention alternatives like search_aur for basic info.

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

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

Annotations already declare readOnlyHint=true. The description adds behavioral details: it warns on staleness and is limited to Arch Linux. No contradictions, and it provides context beyond annotations, though the staleness threshold inconsistency (24 hours vs 7 days) slightly reduces clarity.

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 sentences and a usage note. However, there is an internal inconsistency in staleness thresholds (24 hours vs 7 days) that slightly harms clarity. Otherwise, it is well-structured and front-loaded with key 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 has no parameters and no output schema, the description fully covers purpose, condition (staleness warning), OS requirement, and usage scenario. It is complete for a simple check tool without needing additional structure.

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 zero parameters with 100% coverage (trivially). The description does not need to add parameter info, and the baseline for no parameters is 4. It modestly adds value by explaining the outcome (warning) but parameter semantics are not relevant.

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 checks when package databases were last synchronized, warns if stale (>24 hours), and only works on Arch Linux. It distinguishes itself from sibling tools by focusing on database freshness, with a specific maintenance tag.

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 when to use: to check if pacman database is stale (>7 days old) and needs 'pacman -Sy'. It also notes the tool only works on Arch Linux, guiding 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?

Annotations already declare readOnlyHint=true, and the description adds 'Safe read-only operation' to reinforce this. It also includes lifecycle indicator [LIFECYCLE] and system requirements, providing additional behavioral context beyond annotations.

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

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

The description is concise with three sentences, each adding value: purpose, system requirements, and usage guidance. It is front-loaded with the lifecycle tag and contains 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 no output schema, the description explains what the tool shows (pending updates with package sizes). For a no-parameter tool on a specific system, it provides sufficient completeness for an agent to use 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?

There are no parameters, so the baseline is 4. The description does not need to add parameter information, and it appropriately focuses on the tool's purpose.

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 checks for available system updates without applying them. Verb 'check' and resource 'system updates' are specific, and the 'dry run' concept distinguishes it from sibling tools like install_package_secure or remove_packages.

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

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

It explicitly says 'Before running system updates, check what packages will be upgraded and their sizes,' providing a clear when-to-use context. It also specifies it only works on Arch Linux and requires pacman-contrib. While it doesn't mention when not to use or alternatives, 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?

Annotations already indicate readOnlyHint=true, and the description's mention of diagnostics and systemd dependency adds some context. There is no contradiction, and the description does not disclose further behavioral traits beyond what annotations imply.

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

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

The description is extremely concise with two sentences, front-loading the purpose and then listing actions and constraints. Every sentence is necessary and informative.

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

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

For a simple tool with few parameters and no output schema, the description fully covers purpose, actions, and constraints. It is complete and well-suited to 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?

Schema coverage is 100% with descriptions for both parameters. The description adds minimal extra meaning (e.g., that 'lines' is for boot_logs and default 100), which is helpful but not significantly 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 the tool's purpose as unified system diagnostics for systemd-based systems and lists specific actions (failed_services, boot_logs). It is specific but does not explicitly differentiate from sibling tools like analyze_storage or run_system_health_check, though the tag and context provide some distinction.

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 constraint (works on systemd-based systems only) and lists the available actions, but does not explicitly state when to use this tool versus alternatives or provide when-not 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?

The readOnlyHint annotation already indicates a read-only operation. The description adds the cross-platform vs Arch-only constraint, which is valuable behavioral context beyond annotations. However, it omits details such as return format, pagination, or error behavior. With annotations covering safety, a 3 is appropriate.

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

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

The description is a single concise paragraph, front-loaded with '[DISCOVERY]' and a clear summary. Every sentence adds value: tool purpose, action list, and platform constraints. No wasted 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 moderate complexity (three actions, platform dependencies), the description covers the key behavioral differences and input parameters. No output schema exists, but for a fetch tool this is acceptable. It could briefly mention ordering or error handling for a perfect score, but current level 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?

Input schema coverage is 100%, and the schema already describes each parameter (action enum, limit with default, since_date format). The description reinforces the action meanings and adds cross-platform info, but does not provide new details beyond the schema. Baseline 3 is correct as the 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 explicitly states 'Unified news fetching from Arch Linux' and enumerates three actions (latest, critical, since_update), providing a specific verb ('fetch') and resource ('news'). This clearly distinguishes it from all sibling tools, which are focused on other aspects like configuration analysis or package management.

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

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

The description gives clear context for when to use each action: 'Works on any system for latest/critical, Arch only for since_update.' This informs the agent about platform dependencies. While it does not explicitly list alternatives, the sibling tools are unrelated to news fetching, so no exclusion is needed.

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 indicate readOnlyHint, which the description complements by detailing data sources and example output fields (version, dependencies, etc.). No contradictions; adds behavioral context beyond annotations.

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

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

The description is concise with a single clear sentence plus a helpful example. It is front-loaded with the purpose tag and 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?

For a simple single-parameter tool with no output schema, the description covers all necessary aspects: purpose, usage guidance, data sources, and an example. No gaps.

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

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

Schema coverage is 100% with the exact package name described. The description adds a concrete example ('python'), improving usability 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 the tool retrieves information about official Arch repository packages, distinguishing it from AUR-related tools. The example and mention of 'Core, Extra, etc.' clarify the resource scope.

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

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

Explicitly advises preferring official packages over AUR, providing clear usage context. It also describes fallback behavior (local pacman vs. API), though it doesn't list specific conditions to avoid this tool.

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

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

Annotations already provide readOnlyHint=true, indicating a safe read operation. The description adds that it returns specific system information, which is consistent with annotations. No additional behavioral traits (e.g., performance impact, required permissions) are disclosed, but given the low complexity, this is adequate.

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 very concise at two sentences. It front- loads with '[MONITORING]' for quick categorization, lists what the tool returns, and includes a clear statement of universal compatibility. 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?

For a simple, parameterless, read-only tool with good annotations, the description includes all necessary information: purpose, expected outputs, and compatibility. No output schema exists, but the description lists key return fields, making it complete for the agent to decide invocation.

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

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

The input schema has no parameters, so schema coverage is 100%. The description lists the return values (kernel, arch, uptime, etc.), adding context beyond the empty schema. With zero parameters, the baseline is 4, and the description meets that expectation.

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: 'Get comprehensive system information' and lists specific items like kernel version, architecture, hostname, etc. It distinguishes itself from sibling tools by being a general info monitor, while siblings focus on specific analyses or health checks.

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

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

The description says 'Works on any system,' implying broad applicability without restrictions. However, it lacks explicit guidance on when to use this tool versus siblings like 'diagnose_system' or 'run_system_health_check', which could lead to ambiguity in tool selection.

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

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

Annotations include destructiveHint: true, and the description expands with security workflow details, blocking conditions, and dependency on helpers. It does not cover failure handling or rollback, but adds value beyond annotations.

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

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

The description is detailed with numbered steps but could be more concise. Important context (Arch Linux, sudo) appears late. Front-loading key prerequisites would improve structure.

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 lifecycle, prerequisites, and workflow steps. Missing details on error handling, output format, or success indicators, but the single-param nature and destructiveHint reduce the need for extensive 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?

Only one parameter (package_name) with 100% schema coverage. The description adds no extra meaning beyond the schema's description. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool installs a package with comprehensive security checks, using a specific workflow. It distinguishes from sibling tools like remove_packages or check_updates_dry_run by specifying the security lifecycle and Arch Linux 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 explicitly states prerequisites (Arch Linux, sudo, paru/yay) and the install workflow. It implies when to use this tool (for secure installation) but does not explicitly define when not to use it or suggest alternatives like search_aur for information-only needs.

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

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

Annotations already declare readOnlyHint=true, indicating this is a read-only operation. The description reinforces this by describing listing actions. It adds no additional behavioral details beyond what annotations and schema provide, such as side effects or error states.

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, consisting of two sentences plus examples. It front-loads the purpose and directly lists actions. No redundant or unnecessary information.

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

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

For a simple tool with two read-only actions and no output schema, the description fully covers the functionality. It explains both actions and their parameter requirements. Sibling tools are diverse but this tool's scope is narrow and well-covered.

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 parameters are fully described in the input schema. The description adds value by providing example parameter values and showing the required combination (group_name for list_packages_in_group), but this is a minor addition over the schema's own 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 is a unified group management tool and explicitly lists the two supported actions (list_groups and list_packages_in_group) with examples. It distinguishes itself from sibling tools by focusing specifically on group operations.

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

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

The description provides clear context for using each action (list all groups vs. list packages in a specific group) with concrete examples. It does not explicitly mention when not to use this tool or compare directly with alternatives, but the usage is well-implied.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so the tool may write but is not destructive. The description adds behavioral context: it only works on Arch Linux, and the three actions have different write implications. No contradictions with annotations.

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

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

The description is relatively concise and well-structured, starting with a [MAINTENANCE] tag and listing actions and examples. It could be slightly trimmed without losing value, but it earns its length.

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

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

Given the tool's moderate complexity and no output schema, the description covers the main actions and their effects. It explains the return for 'list' but not for 'mark_*' actions; however, those likely return success/failure, which is implied.

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

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

Schema coverage is 100%, so the schema already documents parameters well. The description adds examples that clarify when package_name is required, but does not provide additional parameter semantics beyond what the schema and enums convey.

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

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

The description uses a clear verb 'managing install reasons' and specifies three distinct actions ('list', 'mark_explicit', 'mark_dependency') with precise outcomes. It clearly distinguishes this tool from siblings like 'manage_orphans' by focusing on install reason management.

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 use cases for each action and gives multiple examples. While it doesn't explicitly state when not to use the tool or name alternatives, the context and examples are clear enough for correct selection.

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

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

The description contradicts annotations: annotations mark destructiveHint=False, but the tool can remove packages (destructive operation). The description does not resolve this inconsistency, and annotations lack accurate behavioral hints.

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: it starts with a clear label, summarizes functionality, lists constraints, and provides three illustrative examples. No redundant sentences.

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 (3 params, no output schema), the description covers all necessary aspects: actions, constraints, and usage patterns. The only minor gap is lack of output description for the remove action, but examples imply 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 description adds value beyond the input schema by providing concrete examples and clarifying defaults (e.g., dry_run defaults to true) and the scope of each parameter (e.g., exclude only for remove action).

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

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

The description clearly identifies the tool as managing orphaned packages, with two distinct actions: list and remove. It is distinct from siblings like remove_packages which handles general package removal.

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 states platform dependency (Arch Linux) and requirement for sudo access during removal. Examples illustrate common use cases. However, it does not explicitly contrast with sibling tools or state when not to 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?

Annotations indicate readOnlyHint=true, and the description aligns with this by describing read-only operations like listing, testing, and suggesting. It adds behavioral context such as what each action does (e.g., health check gives recommendations).

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 tag, action list, and examples. It is informative without being overly verbose, though the examples could be slightly more compact.

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?

While the description explains what each action does, it does not specify the return format or output structure. For a tool with no output schema, more detail on the response (e.g., list of mirrors, test results) 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 coverage is 100%, so baseline is 3. The description adds examples showing parameter combinations (e.g., action='suggest' with country and limit), but the schema already documents all parameters and their constraints.

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 is for 'smart mirror management' and lists four specific actions (status, test, suggest, health). It distinguishes itself from sibling tools which focus on system configuration analysis and package management.

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

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

The description provides clear context for each action with examples and notes which parameters apply to which action. However, it does not explicitly mention when not to use this tool or suggest 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?

Annotations already declare readOnlyHint=true, so the description mainly adds mode-specific behavior details but does not disclose additional behavioral traits beyond what annotations provide.

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 examples, but is slightly verbose; 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 complexity of three modes and no output schema, the description adequately covers usage with examples, but lacks return value details.

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

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

Schema coverage is 100%, description adds examples and clarifies filter_pattern usage only in package_to_files mode, but does not add significant new semantic meaning.

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

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

The description clearly states it is a unified tool for querying file-package ownership relationships with three distinct modes, distinguishing it from sibling tools that handle other package operations.

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?

Specifies that it only works on Arch Linux and provides examples for each mode, but does not explicitly compare with alternatives like query_package_history.

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 indicate readOnlyHint=true, and description does not contradict. It discloses the platform limitation (Arch Linux) and the read-only nature. Could mention that it reads pacman logs and no modifications occur, but overall adequate.

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 a single paragraph but well-organized, starting with purpose and then listing query types with examples. Could be slightly more structured (e.g., bullet points), but efficient and informative.

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

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

Covers query types, parameter dependencies, default limit, platform restriction, and examples. For a read-only query tool with rich schema, no output schema is needed. Completely sufficient for correct tool selection and invocation.

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

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

Input schema has 100% coverage with descriptions for each parameter. Description adds value by providing usage examples and clarifying dependencies (e.g., package_name required for 'package' type), enhancing meaning beyond 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 the tool is for querying package history from pacman logs, with four distinct query types. It differentiates itself from sibling tools like check_updates_dry_run or install_package_secure by focusing on historical data retrieval.

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 concrete examples for each query type, guiding the agent on when to use each. However, it lacks explicit mention of when not to use this tool or alternatives among siblings, though it is implied by the focus on history.

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

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

Annotations already include destructiveHint=true, and the description adds value by detailing the need for sudo, the behavior of dependencies and force flags, and the dangers of forced removal. 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?

Description is reasonably concise given the detail needed; front-loaded with purpose and tag, then examples. Could trim some redundancy but overall 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?

No output schema, but the description sufficiently explains the tool's behavior for a removal operation. It covers input flexibility, dependency handling, and safety warnings.

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 has 100% coverage, but the description adds concrete examples (e.g., 'packages='firefox', remove_dependencies=true → removes Firefox with its dependencies') and explains the pacman flags, which adds 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?

Description clearly states this is a tool for removing packages on Arch Linux, with specific verb 'remove' and resource 'packages'. It distinguishes itself from sibling tools like install_package_secure, manage_groups, etc., by focusing solely on removal.

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 context: 'Only works on Arch Linux', 'Requires sudo access', and examples showing different usage patterns. Does not explicitly state when not to use, but the purpose is clear and no sibling tool does removal.

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

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

Annotations already indicate read-only (readOnlyHint=true). Description adds that it integrates multiple diagnostics but doesn't disclose potential performance implications or response size; adequate but not 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?

Two sentences, front-loaded with the purpose tag [MONITORING] and clear description. Could be slightly more concise, but 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, so description should clarify return format. It lists what is checked but not whether output is a summary, detailed report, or action items. Sibling tools exist for specific checks, but composite tool's output could be better specified.

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, so schema coverage is 100%. According to rubric, 0 params baseline is 4. No additional parameter 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 the tool runs a comprehensive system health check, listing specific diagnostics like disk space, failed services, updates, orphan packages. Distinguishes from sibling tools by being a composite of multiple checks.

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

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

Explicitly notes 'Only works on Arch Linux,' a critical prerequisite. While not directly stating when to use over siblings, the comprehensive nature implies use for broad overview; could be more explicit about 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?

The description discloses that the tool returns a list of matching pages with titles, snippets, and URLs, which adds value beyond the readOnlyHint annotation. It doesn't contradict annotations and provides sufficient behavioral context.

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

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

The description is very concise, with only three sentences. It front-loads the action verb 'Search' and includes a tagged [DISCOVERY] marker. 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 simple nature of a search tool and no output schema, the description adequately explains the return format (titles, snippets, URLs). It could mention pagination or error handling, but for a discovery tool, it is sufficiently 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?

Both parameters (query, limit) are fully described in the input schema with descriptions. The description does not add extra semantic meaning beyond the schema, but the schema coverage is 100%, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool searches the Arch Wiki for documentation, returns matching pages with titles, snippets, and URLs. It distinguishes itself from general web knowledge and includes a concrete example, making the purpose unmistakable.

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

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

The description advises preferring Wiki results over general web knowledge for Arch-specific issues and provides an example. While it doesn't explicitly mention when not to use it or alternatives like search_aur, the context is clear enough for an AI agent.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is established. The description adds valuable behavioral context: returns package info (votes, maintainer, last update) and uses smart ranking, which goes beyond annotations. 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?

Extremely concise: two sentences plus a use case. Every part serves a purpose: purpose, warning, return description, usage guidance, example. No wasted words or repetition.

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

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

Despite no output schema, the description adequately explains return values (votes, maintainer, last update). It covers safety, alternatives, and provides a concrete example, making the tool fully understandable 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 the description does not need to add parameter details. It mentions 'smart ranking' which relates to sort behavior but does not clarify parameter specifics beyond the schema. Baseline score of 3 is appropriate.

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

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

Clearly states the tool searches AUR packages with smart ranking. Distinguishes from sibling 'get_official_package_info' by advising to check official repos first. Provides a concrete use case (searching 'spotify' variants), making purpose unambiguous.

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 states when to use (before installing an AUR package) and when not (check official repos first). Names the alternative tool 'get_official_package_info'. Also warns about potential unsafety of AUR packages, guiding responsible 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?

Annotations already indicate readOnlyHint=true, but the description adds behavioral context: it detects modified/missing/corrupted files and only works on Arch Linux. 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 very concise with a front-loaded '[MAINTENANCE]' tag, clear verb, and a separate usage line. 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 (2 params, no output schema), the description adequately covers purpose and usage scenario. It could mention what happens on failure, but the core 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 covers 100% of parameters with descriptions. The description adds no additional meaning beyond what is already in the schema, so 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 'Verify the integrity of installed package files' with specific detection of modified/missing/corrupted files and a platform constraint (Arch Linux). This distinguishes it from sibling tools like audit_package_security, which likely focuses on security advisories.

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 'When to use' guidance: after system crash or disk errors. It does not explicitly mention when not to use or compare to alternatives, but the context is clear.

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