Utility Matrix

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

Annotations indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing a safe, non-destructive calculator. The description adds the specific outputs (noise rate, wasted hours, fatigue tier) and the required inputs, providing behavioral context 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?

The description consists of two concise sentences: the first specifies when to use, the second states inputs and outputs. Every word is purposeful, no fluff or repetition. Well 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 tool has an output schema (not shown) but the description lists the three return values, covering the essential output. For a calculator with clear inputs and annotations, the description is nearly complete. A minor gap: it doesn't mention that it's a read-only calculation, but annotations already cover that.

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% (no parameter descriptions in schema). The description lists the four inputs using plain terms ('weekly alert volume, actionable %, engineer count, and avg resolution time') but does not explain each parameter's meaning or constraints (e.g., what actionable_pct represents). The names are somewhat self-explanatory, but more detail would compensate for the schema gap.

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

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

The description clearly states the tool's purpose: it calculates alert fatigue metrics like noise rate, wasted hours, and fatigue tier. It explicitly ties usage to user queries about alert noise, fatigue, or on-call burden, distinguishing it from sibling calculator 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 when to use the tool ('when a user asks about alert noise, alert fatigue, or on-call burden'). It does not provide explicit alternatives or exclusions, but the sibling list contains related calculators (e.g., on-call-burden-calculator) that may serve as alternatives, providing contextual 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?

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent already knows it is safe and idempotent. The description adds that it returns a score and rating, but does not disclose additional behavioral traits like potential precision or edge cases. Given the annotations, the description provides adequate but not rich context.

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

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

The description is two sentences, starting with an explicit usage instruction. Every sentence adds unique value: first sentence defines when to use, second describes inputs and outputs. 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?

Given the tool is a simple calculator with an output schema (exists but not shown), the description covers usage, inputs, and outputs. It does not mention the formula or that total must be at least satisfied+tolerating, but these are minor gaps. The annotations and schema cover safety constraints, making the description fairly complete.

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

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

The input schema has 0% description coverage, so the description must compensate. It states 'Takes satisfied, tolerating, and total request counts,' explaining the role of each parameter. This adds meaning beyond the raw schema types, though it lacks details like format or validation constraints which are partly in 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: calculating an Apdex score to measure user satisfaction with response times. It specifies the inputs (satisfied, tolerating, total request counts) and outputs (Apdex score and performance rating). This distinguishes it from sibling calculator tools like change-failure-rate-calculator or mtbr-calculator.

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 a user asks about their Apdex score or wants to measure user satisfaction with response times,' providing clear context for when to invoke the tool. However, it does not mention alternatives or explicitly state when not to use it, though the sibling list implicitly covers other calculators.

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, idempotentHint=true, and destructiveHint=false. The description adds that it calculates downtime budgets, which is consistent and provides useful behavioral context 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?

Two sentences with zero waste. The first sentence front-loads the usage context and condition, the second specifies the outputs. All sentences are essential.

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 exists), the description fully covers what the tool does and when to use it. No missing 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% with a clear description of the single parameter (availability_pct) and example. The description reiterates the concept but does not add additional 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 clearly states the tool converts availability SLA percentage to downtime budgets. It specifies the verb (converts) and resource (availability percentage), and the specificity (downtime minutes per month or year) distinguishes it from sibling calculators.

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: 'when a user asks what a specific availability percentage means in downtime minutes per month or year.' It provides clear context but does not mention when not to use or name alternatives, though sibling tools are for different metrics.

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, idempotent, non-destructive behavior. The description adds transparent details about the specific checks performed (missing, self-referencing, relative), which is valuable beyond the annotations. No contradictions found.

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: the first states the purpose, the second lists detection types. Every word is necessary, and the structure is front-loaded with the action. No 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?

Given the presence of an output schema (not shown but known), the description need not detail return values. It covers the tool's core function and the types of issues detected, which is sufficient for an agent to understand and invoke it correctly.

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

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

Schema description coverage is 100%, with both parameters well-documented (page_url and canonical). The description adds minor context about the meaning of an empty canonical string (missing), but does not substantially enhance 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 the tool audits a page URL against its canonical tag, specifying the exact issues it detects: missing, self-referencing, and relative URL problems. This distinguishes it from sibling calculators and checkers, which cover different domains.

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

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

The description implies the tool is for canonical tag audits but does not provide explicit guidance on when to use it versus alternatives or when not to use it. The sibling context suggests a specific use case, but no exclusions or conditions are stated.

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

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

Annotations already indicate readOnly and idempotent behavior. Description adds risk level thresholds and conditions (e.g., WARNING at <30 days), providing useful 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?

Single, focused sentence that covers purpose, inputs, and outputs with no extraneous words. 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 annotations, complete schema, and existence of output schema, the description adequately explains the tool's function and behavior. Return format details are likely covered by output schema.

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 both parameters are well-described in the schema. The description only mentions 'domain and days remaining' generically, adding minimal value 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?

Clearly states verb 'assess' and resource 'certificate expiry risk' with specific thresholds. Distinguishes from sibling tools which are calculators or auditors, not certificate-focused.

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?

Implied usage context (when you have domain and days remaining) but no explicit guidance on when to use vs alternatives or when not to use. No exclusions or alternative tools 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that the tool returns 'failure rate percentage and DORA tier', which provides output information beyond annotations. This is helpful but limited behavioral context.

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

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

The description is two sentences, front-loaded with the use case, and every word contributes meaning. No redundancy or missing 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?

For a simple calculator with two numeric parameters and no side effects, the description fully covers what the tool does, when to use it, and what it returns. The output schema exists (implied) but is described adequately.

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 parameter description coverage, the description must compensate. It identifies the parameters implicitly by stating 'Given total and failed deployments', but does not explain the meaning of each parameter beyond their role in the calculation. No additional constraints or formats are provided, so it adds minimal value over basic naming.

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 computes change failure rate and returns percentage and DORA tier. It explicitly mentions the trigger 'when a user asks about change failure rate or DORA CFR', which distinguishes it from sibling calculator 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 provides a clear condition for use ('when a user asks about change failure rate or DORA CFR'). However, it does not specify when not to use this tool or mention alternatives explicitly, though the context implies it's for that specific metric.

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, idempotentHint=true, destructiveHint=false. The description adds 'returns waste estimate and tier' but does not elaborate on side effects or behavior beyond what annotations imply. With comprehensive annotations, the added value is minimal.

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 that are direct and front-loaded: first sentence states usage, second describes inputs and output. 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 an output schema exists (not shown), the description need not detail return values beyond 'waste estimate and tier.' It mentions the required input and the type of output, but could be more specific about the need for a monthly_cloud_bill as required. Still, it is mostly complete for a simple calculator.

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%. The description mentions 'monthly cloud bill and idle/oversized percentages' but does not explain the 'unattached_volumes_count' parameter or the precise meaning of idle_pct/oversized_pct. For a calculator, parameters are somewhat self-explanatory, but given no schema descriptions, the tool description should provide more 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 the trigger (user asks about cloud waste, idle resources, or unattached storage) and the action (returns waste estimate and tier). It distinguishes from sibling calculators which are about other specific metrics (e.g., alert-fatigue, ec2-cost).

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 'Use when a user asks about cloud waste, idle resources, or unattached storage,' providing clear when-to-use guidance. It does not explicitly state when not to use, but the sibling list implies alternatives are different calculators.

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 idempotentHint=true, so the agent knows the tool is safe and side-effect-free. The description adds that it 'returns cluster utilization and headroom,' which is useful but not extensive. No contradictions found.

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, no filler. The first sentence states the use case, the second lists inputs and outputs. Every word earns its place, and the description is easy to scan.

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 6 parameters (3 required), a 0% schema description coverage, and an existing output schema, the description covers the core inputs and mentions outputs. The grouping of 'resource requests' is slightly vague but sufficient. It does not detail the output schema, but that is acceptable since an output schema exists.

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

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

Schema description coverage is 0%, so the description must explain parameters. It names 'node count (nodes)', 'CPU cores per node (node_cpu)', 'memory per node in GB (node_memory_gb)', 'pod count (pods)', and 'resource requests' (implicitly covering pod_cpu_m and pod_memory_mb). While it adds meaning, it does not explicitly list pod_cpu_m and pod_memory_mb, leaving some ambiguity.

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: evaluating Kubernetes cluster capacity and headroom. It specifies the exact scenario ('whether their Kubernetes cluster has enough capacity, or how many more pods they can schedule'), which distinguishes it from sibling calculators that address other metrics (e.g., cloud waste, error budgets).

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 when to use this tool ('when a user asks whether their Kubernetes cluster has enough capacity...'), providing clear context. However, it does not mention when not to use it or suggest alternative tools for non-Kubernetes capacity questions, which would strengthen 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating no side effects. The description adds value by specifying that the tool returns 'recommended pool size per instance with utilization ratio', which is behavioral info beyond the annotations. No contradiction.

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

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

The description is three sentences, front-loading the use case, then listing inputs and outputs. No redundant information. Every sentence contributes 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?

The tool is simple with 3 parameters, has an output schema, and annotations cover safety. The description explains when to use, what inputs (though minimally), and what outputs are returned. It is complete for this calculator-level 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 has 0% parameter description coverage. The description mentions 'Takes CPU cores, app instances, and max_connections', which repeats names but adds minimal context (e.g., 'app instances' might mean application server instances, but not clarified). It does not explain units or constraints, so it provides only modest additional 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 clearly states the tool's function: calculating recommended pool size for database connections. It uses specific verbs ('use this when', 'returns') and specifies the resource (connection pool, PostgreSQL). It is distinct from sibling calculators like 'cluster-capacity-calculator' or 'slo-burn-rate-calculator' by explicitly mentioning connection pool and PostgreSQL.

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 the tool: when a user asks about configuring database connection pool size or troubleshooting PostgreSQL connection exhaustion. It does not provide when-not-to-use examples, but the context of sibling calculators makes the usage context 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds no additional behavioral context (e.g., how the calculation works or any side effects), but it does not contradict 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 a single concise sentence with no wasted words, and it is front-loaded with the key usage context.

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 an output schema, the description does not need to explain return values. However, it lacks parameter explanations and does not specify the calculation formula or assumptions. For a simple calculator, this is adequate but leaves room for ambiguity.

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

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

Schema description coverage is 0%, so the description must compensate for explaining parameters. The description does not mention any parameter names or roles. While parameter names like 'deploys_per_month' and 'team_size' are self-explanatory, the lack of any description of how they are used or constraints is a significant gap.

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

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

The description states the tool is for deployment frequency or DORA deploy cadence, which clearly implies its purpose. However, it uses a 'use when' phrasing rather than a direct verb+resource statement, and it does not explicitly differentiate from the sibling 'dora-metrics-calculator' which may also cover this metric.

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 when to use the tool (when deployment frequency is asked), but it provides no guidance on when not to use it or which alternative(s) to choose among siblings, such as 'dora-metrics-calculator' for comprehensive DORA metrics.

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, idempotent, non-destructive behavior. The description adds valuable context about the output: redacted matches and severity classification. No contradiction with annotations, and the description complements them 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?

Two concise sentences that front-load the core purpose and follow with output details. No redundant words; every sentence adds value. Ideally structured for an agent to quickly grasp functionality.

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 (single parameter, clear purpose, output schema exists), the description fully covers what the agent needs to know to select and invoke the tool correctly. No missing 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% for the single 'text' parameter. The description adds semantic value by specifying the types of content (config, code, env files) beyond the schema's description, helping the agent understand what input 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 specifies the tool scans text for leaked secrets (API keys, tokens, passwords, private keys) and returns findings with redacted matches and severity classification. The verb 'scan' and resource 'text' are specific, and the description distinguishes this tool from sibling tools which are primarily calculators and linters.

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 the tool is for scanning config, code, and env file content. The sibling context shows no similar secret scanning tools, so usage is clear. No explicit 'when not to use' or alternative tools are mentioned, but the purpose is sufficiently distinct.

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 read-only, idempotent, non-destructive behavior. The description adds transparency by specifying the exact issues checked and the return format (issues with suggestions per instruction), which supplements the safety profile.

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 front-loads the purpose and key checked issues, containing zero waste. Every word contributes to understanding the tool's function.

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 linter with an output schema, the description covers the main use case and return format. It is complete enough but could briefly mention that it is safe to run multiple times (already implied by annotations).

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 a clear description of the 'dockerfile' parameter. The tool description does not add any additional meaning beyond what the schema already 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 the tool lints a Dockerfile for specific common issues (latest tag, interactive installs, root user) and returns issues with suggestions per instruction, distinguishing it effectively from sibling linters like kubernetes-manifest-linter.

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

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

No guidance is provided on when to use this tool versus alternatives or when not to use it. The description only states what it does without explicit usage 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety. The description adds that it returns tier classification per metric, which is useful but does not disclose thresholds or further behavior. 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 a single paragraph of three sentences, front-loaded with the usage cue. Every sentence is informative and there is 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?

With 4 parameters (3 required) and an output schema present, the description covers the high-level input and output meaning. It does not explain the classification thresholds or tier definitions, but the output schema likely provides structure. Some additional context on the tiers 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 description coverage is 0%, meaning the schema provides no parameter descriptions. The description maps parameters to metric names (deploy frequency, lead time hours, etc.) but does not specify units, acceptable ranges, or format (e.g., what scale for change_failure_pct). This is insufficient compensation for zero 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 verb ('benchmark'/'classify'), the resource ('engineering team against DORA metrics'), and the output ('Elite/High/Medium/Low tier classification per metric'). It distinguishes from sibling tools like 'deployment-frequency-calculator' by being a composite classifier.

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 starts with 'Use this when a user wants to benchmark...or classify...', providing clear context. However, it does not explicitly list alternative tools or when not to use this tool, leaving some ambiguity for edge cases.

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, idempotent, non-destructive. Description adds that the tool returns monthly cost and DO-equivalent savings, which is valuable 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?

Two sentences, no wasted words. Front-loads the usage trigger and clearly defines inputs and outputs. 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?

For a simple calculator with an output schema, the description provides enough context: inputs, what is computed, and the nature of the output (monthly cost and savings estimate). Could mention that the output schema contains details, but not required.

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 3 parameters with 0% schema description coverage. The description does not detail individual parameters (os, instance_type, hours_per_month) or their formats, leaving the agent to infer from names alone. The description implies hours_per_month is used but doesn't clarify defaults or allowed values.

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 computes EC2 cost given instance type and hours, and returns monthly cost with DO-equivalent savings estimate. Distinguishes from sibling calculators by specificity to EC2 and DO comparison.

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 'Use when a user asks about EC2 cost', providing clear context. Lacks explicit exclusions or alternatives, but the usage is well-scoped.

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 destructiveHint=false, so the description adds value by specifying the pricing model ('AWS tiered pricing') and the output nature ('estimated monthly egress cost'). 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 consists of two concise sentences with no extraneous words. The first sentence provides usage guidance, and the second clarifies input and output. It is 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 tool's simplicity (one mandatory parameter, no nested objects, existing output schema), the description sufficiently covers input, output, and usage context. It does not mention assumptions like pricing region or data tiers, which could enhance completeness, but overall 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?

With 0% schema description coverage for the single parameter, the description compensates by stating that the input is 'monthly transfer volume in GB,' adding clarity beyond the parameter name. It does not provide constraints like accepted range or default value, but for a simple number parameter, this is adequate.

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 estimates AWS data transfer/egress costs based on monthly transfer volume. It uses specific verbs ('estimate', 'calculate') and resources ('AWS data transfer', 'egress cost'), effectively distinguishing it from sibling cost calculators like ec2-cost-calculator or cloud-waste-calculator.

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 the tool ('when a user asks how much AWS data transfer or egress costs...'). However, it does not provide exclusion criteria or mention alternatives for other types of cost queries, which would improve differentiation among the many sibling calculators.

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, idempotentHint=true, destructiveHint=false, indicating a safe, read-only calculation. Description adds context about output including status levels (Under budget / Elevated / ALERTING), which is beyond annotations. No behavioral pitfalls disclosed, but the safety profile is covered.

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

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

Two sentences: first sets usage context, second describes inputs and outputs. Minimal waste, front-loaded with key information. Every sentence serves a clear purpose.

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?

Provides high-level purpose and output fields, but lacks details on optional parameters (consumed_minutes, window_elapsed_days) and their units. Without this, the agent may underutilize the tool's full capability. Output schema exists but isn't shown. Given 4 parameters and 0% schema coverage, description could be more 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 0%, so description must compensate. It mentions only 'SLO percentage and window', which maps to slo_pct and window_days, but omits consumed_minutes and window_elapsed_days. These are optional but critical for accurate calculation when budget is partially consumed or window partially elapsed. Description provides no meaning beyond schema property 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?

Description clearly states the tool calculates SLO error budget, remaining error budget, or burn rate. It specifies inputs (SLO percentage and window) and outputs (budget minutes remaining, burn rate multiplier, status). Differentiates from sibling calculators like slo-burn-rate-calculator by focusing on overall error budget with status levels.

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 'Use this when a user asks about their SLO error budget, remaining error budget, or burn rate.' Provides clear context for when to invoke. Does not mention when not to use it or alternative tools, but the sibling list implies other calculators for different metrics. Overlap with slo-burn-rate-calculator is ambiguous but not ruled out.

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 the tool is read-only and idempotent, which the description supports implicitly. The description discloses it returns revenue impact, engineering cost, and total cost. However, it omits the optional parameters 'eng_hourly' and 'responders', which are part of input schema but not explained in the description, causing a transparency gap.

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

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

The description is three sentences, front-loaded with the use case, and contains no superfluous words. It efficiently conveys purpose, inputs, and outputs.

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 return values (revenue impact, engineering cost, total cost) but does not clarify optional parameter behavior or how engineering cost is computed. Given the presence of an output schema, the description is moderately complete but leaves gaps in parameter semantics.

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

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

The description mentions three parameters (hourly_revenue, downtime_hours, affected_pct) but omits two optional parameters (eng_hourly, responders) from the schema. With 0% schema description coverage, the description should explain all parameters, but it only covers 60%, and for the mentioned ones it adds minimal meaning (e.g., 'affected percentage' without clarifying it's optional).

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 calculates financial impact of downtime/outage, using a specific verb ('calculate') and resource ('incident cost'). It distinguishes from sibling calculators like 'cloud-waste-calculator' or 'ec2-cost-calculator' by specifying the outage 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 says 'Use this when a user asks what an outage or incident cost', providing clear context. However, it does not mention when not to use it or suggest alternative tools for related but distinct calculations.

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 safety hints (readOnlyHint, idempotentHint). The description adds return fields (vulnerability status, CVE ID, severity) and scope hint ('common packages'), providing useful 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?

Two concise sentences with front-loaded action. No extraneous 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?

With one parameter, full schema coverage, and output schema, the description covers core functionality. The phrase 'common packages' is slightly ambiguous but sufficient for a low-complexity 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% and explains the parameter well. The description does not add new semantic details beyond examples present in schema. 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?

Clearly states the verb 'Check' and resource 'package name against a database of known CVEs'. Distinguishes from sibling tools like 'detect-secrets-scanner' or 'dockerfile-linter' by focusing on CVEs for common 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?

No guidance on when to use this tool versus alternatives, no exclusions or prerequisites. Simply describes functionality without contextual usage advice.

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, idempotentHint=true, destructiveHint=false, indicating safe, non-destructive behavior. The description adds that the tool returns an issue list and severity, providing output context 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 a single, well-structured sentence that front-loads the verb and resource, then lists specific checks. No superfluous text; every word 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 simple one-parameter input and presence of an output schema, the description adequately explains what the tool does and what it returns. 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?

With 100% schema coverage and one parameter fully described as 'Kubernetes manifest YAML content', the description adds minimal extra semantics. It mentions YAML but does not elaborate on format or validation, 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 the tool lints Kubernetes manifests and lists specific issues it checks (missing resource limits, health checks, :latest tag, privileged containers). This differentiates it from sibling linters like dockerfile-linter or known-vulnerability-checker.

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 Kubernetes manifest validation but does not explicitly state when to use this tool over sibling linters or provide prerequisites. Usage context is clear but lacks explicit guidance on alternatives or 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 already declare readOnlyHint=true, so no safety concerns. The description adds value by specifying input formats (string lines or array of objects), which is 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?

Two sentences: first states purpose, second explains input. No fluff, front-loaded, every sentence earns its place.

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

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

Given the presence of an output schema (not shown), return values need not be explained. Input format is covered. For a calculator tool, this is adequate, though aggregate behavior is unspecified.

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 defines 'incidents' as an empty object (0% coverage). The description compensates by detailing two valid formats (string lines with start,detected,resolved or array of objects). This adds meaning but could be more precise about timestamp format.

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 for answering MTTR or DORA recovery time questions, which is a specific verb+resource. It distinguishes from sibling calculators by focusing on recovery time, 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?

The description explicitly says 'Use when a user asks about MTTR or DORA recovery time,' providing clear context. It does not explicitly exclude alternatives, but the specificity makes it easy to decide among 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?

Annotations already indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds no behavioral details beyond these hints, missing an opportunity to explain the tool's behavior, such as whether it computes a monetary cost or a risk index.

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 is front-loaded and not verbose. However, it is too sparse to be fully helpful, sacrificing informativeness 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?

Despite having an output schema, the description lacks details about what the tool returns or how to interpret results. Combined with no parameter guidance, the description is inadequate for correct invocation, especially given four required parameters.

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 mention any of the four parameters (engineer_count, shifts_per_month, hours_per_shift, hourly_cost) or their roles. With 0% schema description coverage, the description should compensate but fails to provide any parameter meaning.

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

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

The description clearly states the tool's purpose: assessing on-call load or burnout risk. It uses a specific verb ('use when') and identifies the topic, but lacks detail on what exactly is calculated (e.g., cost or risk score).

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 clear context for when to use the tool ('when a user asks about on-call load or burnout risk'), but it does not specify when not to use it or how it differs from sibling calculator tools, such as alert-fatigue-calculator or slo-burn-rate-calculator.

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, idempotentHint, and no destruction. The description adds return format (monthly billing cost with breakdown) but does not disclose deeper behavior like rate limiting or authentication needs.

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 fluff, efficiently communicating purpose, inputs, and output.

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 existence of an output schema (assumed to describe the return value), the description covers the essential information: inputs and output summary. It could mention the runner multiplier breakdown more explicitly but 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 0%, so the description must compensate. It lists the four parameters (average job duration, jobs per run, monthly run count, runner type) but provides no additional semantics like units or value 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 specifies a clear action (calculate cost) and resource (GitHub Actions CI/CD pipeline), distinguishing it from other calculators like ec2-cost-calculator. The verb 'calculate' is implied in 'costs per month'.

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: when a user asks for pipeline costs or wants to compare runner costs. It provides clear context but does not mention alternatives or 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 and idempotentHint, so the tool is safe and stateless. The description adds that it 'returns interpretation of the precision-recall tradeoff,' which is behavioral context beyond annotations, but not extensive.

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 uses two sentences, front-loading the purpose and listing inputs and outputs without any redundant information. Every word 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 the tool's simplicity (3 parameters, output schema exists), the description covers the core functionality: what triggers use, what inputs are expected, and what outputs are returned. It could mention the default beta of 1, but overall 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?

Schema description coverage is 0%, so the description must compensate. It names the parameters ('precision, recall, and optional beta weight') but does not elaborate on their ranges or semantics beyond the schema constraints. This is adequate but minimal.

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 when to use the tool ('when a user asks about their ML model precision, recall, F1 score, or F-beta score') and what it returns. This clearly differentiates it from sibling calculator tools like apdex-score-calculator or availability-sla-calculator.

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 ('Use this when a user asks about...'), but does not explicitly exclude cases where it should not be used. However, given the specialized sibling tools, the intended use 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 already declare readOnlyHint, idempotentHint, and destructiveHint, so the tool is safe. The description adds behavioral details (heuristic analysis, returns cost score and level) without contradicting 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?

Single sentence, front-loaded with key information, no wasted words. Efficiently conveys purpose, methodology, and output.

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 tool, full schema coverage, and presence of an output schema, the description is complete. It does not need to explain return values as the output schema handles that.

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 query parameter with 100% description coverage. The description adds value by explaining the analysis factors considered, going beyond the schema's minimal 'SQL query to analyze'.

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 estimates relative cost of a SQL query using heuristic analysis. It specifies key factors like SELECT *, JOIN count, missing WHERE/LIMIT, etc., making the purpose distinct from sibling calculators.

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 SQL query costs but does not explicitly state when to use vs alternatives or provide exclusions. No guidance on context or when not to use is given.

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

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

Annotations already indicate read-only, non-destructive, idempotent behavior. The description adds return value details (percentage, buffer, safety status, risk level), which is useful but does not contradict annotations. Without annotations, it would score lower.

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, no fluff. First sentence states purpose and inputs, second lists output fields. 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 presence of an output schema and complete annotations, the description adequately covers the main functionality. However, it omits handling of the optional 'window_seconds' parameter, which might affect interpretation of the limit.

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 parameters. The description only mentions 'current request count and limit' which maps to required parameters, but adds no detail beyond the schema. 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 the verb 'Calculate' and the resource 'API rate limit utilization' with specific inputs. It is distinct from sibling calculators like 'apdex-score-calculator' or 'error-budget-calculator' by focusing on rate limits.

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. While the name and description imply it is for rate limit utilization, there is no mention of prerequisites or comparison to sibling calculators.

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 confirm read-only, idempotent, non-destructive. Description adds that tool returns break-even month and net savings over 1yr and 3yr, going 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?

Three sentences with front-loaded use case. Every sentence serves a purpose: usage context, inputs, outputs. No redundancy or 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?

Tool complexity is low (5 simple number params, no enums). Description covers use case, inputs, and outputs. With an output schema present, return values don't need elaboration. Minor gap: doesn't note that upfront fees are not required.

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%. Description mentions 'On-Demand and RI monthly costs plus upfront fee' but doesn't map to specific parameter names (ri_1yr_upfront vs ri_3yr_upfront) or clarify that upfront fees are optional. Adds minimal meaning beyond parameter names.

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 calculates break-even month and net savings for Reserved Instance purchase decisions, with specific verb 'calculate' and resource 'Reserved Instances vs On-Demand'. It distinguishes from sibling calculators by focusing on RI breakeven 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?

Explicitly states when to use (user asks about buying RIs or breakeven time). Does not explicitly exclude other calculators or provide alternatives, but context is sufficiently specific for an AI agent to select 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 declare readOnlyHint=true and idempotentHint=true, indicating safe read-only behavior. The description adds no behavioral context beyond that, such as what the tool calculates or any prerequisites, which 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 a single front-loaded sentence with no unnecessary words. It efficiently communicates the tool's primary use case.

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 having an output schema and annotations, the description lacks essential information about what the tool computes, how to interpret results, or parameter meanings. With 6 parameters and 0% schema coverage, this is insufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no explanation for any of the 6 parameters (4 required). It does not clarify what current_vcpu, p99_cpu_pct, etc., represent.

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 for 'instance rightsizing or overprovisioned compute' with a specific verb and resource, and it distinguishes from sibling calculator tools like ec2-cost-calculator or cluster-capacity-calculator.

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 when a user asks about...', providing clear context for when to invoke the tool. However, it does not mention when not to use it or suggest 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description adds no new behavioral disclosure. It does not mention assumptions (e.g., constant error rate) or limitations, but for a simple calculator, 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?

Two sentences, front-loaded with usage guidance, then functional description. 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?

For a simple calculator with three parameters and an output schema, the description covers the essentials. It could mention that the period for errors and total must match, but this is implied and output schema likely clarifies return values.

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 0% description coverage, so the description must compensate. It explains that 'errors' and 'total' are counts over a period, and 'slo' is the target (implied as percentage). This adds meaning beyond schema names and types, though units for slo (e.g., 99.9) could be clearer.

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 calculates 'burn rate multiple and time-to-exhaustion signal' based on error count, total requests, and SLO target. It distinguishes from sibling calculators like error-budget-calculator (which likely only returns remaining budget) and availability-sla-calculator.

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: 'Use this when a user asks how fast they are burning their error budget, or whether their current error rate will exhaust their SLO window.' It does not mention when not to use or 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe, idempotent calculation. The description adds no behavioral details beyond what annotations provide, but it does not contradict 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 a single, front-loaded sentence that directly states the use case. Every word earns its place; there is no extraneous 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 having an output schema, the tool has 8 parameters with numeric constraints and no explanation of how inputs relate to risk. The description is minimal, lacking guidance on required inputs or risk factors. It is adequate but incomplete for a complex calculator.

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%, meaning no parameter descriptions exist in the schema. The tool description does not explain any of the 8 parameters (e.g., numUsers, contractLengthMonths), leaving the agent to infer from parameter names. With no enum values or nested objects, the lack of descriptive text is a significant gap.

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

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

The description clearly states the tool's purpose: calculating risk for software purchases or SaaS commitments. The tool name is self-explanatory, and among sibling calculators (e.g., cost, capacity, performance), it uniquely addresses procurement risk.

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 when a user asks about risk of a software purchase or SaaS commitment,' providing direct usage context. It does not explicitly state when not to use, but the specialization among siblings implies exclusivity for risk assessments.

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, idempotentHint=true, and destructiveHint=false, so the description adds no extra behavioral context. It could mention that the estimation is based on the parameters provided, but overall it is consistent and non-contradictory.

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

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

A single sentence that is concise and to the point. No extraneous words, and the instruction 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?

Output schema exists, so return values are covered elsewhere. However, the tool has three parameters relevant to cost estimation, and the description gives no guidance on how they influence the outcome or what resource types are accepted. This is a notable gap.

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

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

Schema coverage is 0%, so the description must compensate but fails to explain `resource_type`, `count`, or `instance_size`. The user is left to guess what values are valid, which is insufficient for a 3-parameter tool.

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

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

The description clearly states the tool estimates monthly cost of a Terraform plan, using a specific verb and resource. It is distinguishable from sibling calculators by explicitly mentioning 'Terraform plan', though it could be more precise about the plan source.

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 when a user asks to estimate monthly cost of a Terraform plan.', providing clear context for when to invoke. It does not list exclusions or alternatives, but the sibling tools are all calculators, making the Terraform-specific scope 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 readOnly and idempotent hints. The description adds no behavior beyond stating the use case. It does not disclose any side effects, prerequisites, or output format.

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 one sentence, which is too terse. It lacks structure and does not earn its place by providing essential information beyond the tool name.

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 (8 parameters, many siblings, output schema exists), the description is severely incomplete. It does not explain inputs, outputs, or how it differs from other cost calculators.

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% and the description does not explain any of the 8 parameters (2 required). The agent must infer meanings from names alone, which is insufficient.

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 for TCO or multi-year SaaS cost questions. It differentiates from sibling calculators like cloud-waste-calculator or ec2-cost-calculator by focusing on total cost of ownership. However, it lacks an explicit verb like 'calculates'.

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 specifies when to use (user asks about TCO/multi-year SaaS cost) but does not mention when not to use or provide alternatives. It gives a clear context but no exclusions or comparisons to siblings.

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