Utility Matrix

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

Annotations already indicate readOnlyHint=true and idempotentHint=true, meaning the tool is safe and deterministic. The description adds value by specifying the outputs (noise rate, wasted hours, fatigue tier), giving behavioral insight beyond 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 two sentences long, with the first sentence stating usage and the second listing inputs and outputs. It is front-loaded, every sentence adds value, and there is 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 that an output schema exists (context signals show 'Has output schema: true'), the description need not detail return values extensively. It covers the purpose, usage condition, and inputs, and mentions the outputs. However, some users might benefit from more context on fatigue tier definitions. Overall adequate.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all four parameters (weekly alert volume, actionable %, engineer count, avg resolution time) but does not provide detailed semantics like units, ranges, or format hints. Schema constraints provide some guidance, but more could be done to clarify, e.g., that actionable_pct is a percentage.

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

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

The description clearly states that the tool calculates alert fatigue metrics and is used when a user asks about alert noise, fatigue, or on-call burden. It distinguishes itself from sibling calculators like 'apdex-score-calculator' or 'mttr-calculator' by focusing specifically on non-actionable alerts and fatigue.

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 alert noise, alert fatigue, or on-call burden from non-actionable alerts', providing clear usage context. It does not explicitly state when not to use, but the sibling list of other calculators implies alternatives. Could be slightly improved with direct exclusions.

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

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

Annotations already indicate safe read-only idempotent operation. Description adds that it returns a score (0-1) and rating, providing useful 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?

Two concise sentences, front-loaded with purpose, 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?

Output schema exists, so return values are covered. Description fully addresses purpose, parameters, and output for this 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?

With 0% schema coverage, description explains parameters as satisfied, tolerating, and total request counts, adding essential meaning beyond bare 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 explicitly states it computes Apdex score for user satisfaction, clearly distinguishing from sibling calculators like error-budget-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?

Explicit 'use when' guidance for Apdex or satisfaction queries. No explicit when-not or alternatives, but sibling context implies differentiation.

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, idempotentHint, and destructiveHint. The description adds behavioral context about what the tool computes (downtime budgets per period) 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?

Two sentences, front-loaded with usage guidance, no extraneous content. Every sentence serves a 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?

Given the simplicity of one parameter, full schema coverage, and presence of an output schema, the description adequately covers what the tool does and its output without needing further detail.

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 covers the single parameter fully with description 'e.g. 99.9 for three nines'. The tool description does not add additional meaning beyond 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 the tool converts availability SLA percentages into downtime budgets, with specific verb 'converts' and resource 'availability SLA percentage'. It distinguishes from sibling calculator tools by its specific function.

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 a specific availability percentage means', providing clear context for when to invoke, and implicitly differentiating from 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 indicate read-only, idempotent, non-destructive. Description adds specific detection behaviors (missing, self-referencing, relative URL), providing deeper 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, front-loaded with verb and resource. Every word adds value, no redundancy.

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

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

Covers purpose and detection capabilities. Output schema exists to handle return details, so description is sufficiently complete for a two-parameter 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 covers both parameters with descriptions. Description repeats issues but does not add new parameter-specific meaning. Schema coverage 100%, baseline 3.

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

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

Clear verb 'Audit' against resource 'page URL against its canonical tag'. Lists specific issues detected: missing, self-referencing, relative URL. Distinct from sibling calculators and checkers.

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

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

Explicit purpose implies when to use: when checking canonical tags. No exclusions or alternatives mentioned, but siblings are distinct enough that no confusion arises.

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 adds behavioral details beyond annotations, specifying the return risk levels and thresholds (OK, WARNING at <30 days, CRITICAL at <7 days, EXPIRED at <0). This complements the read-only, idempotent nature indicated by 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 sentence that efficiently conveys purpose, inputs, and outputs with 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?

For a simple tool with two parameters and an output schema, the description covers all necessary information: inputs, behavior, and return values. It is complete and self-contained.

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 clear parameter descriptions. The description adds minimal extra meaning, only providing a domain format example. 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 uses the specific verb 'assess' and identifies the resource 'certificate expiry risk'. It clearly distinguishes from sibling tools by focusing on certificate expiry, a unique domain among many 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 states when to use the tool (for assessing certificate expiry risk) but does not provide guidance on when not to use it or mention alternative tools, relying on implied 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 declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate. The description adds that it 'returns failure rate percentage and DORA tier', which is useful behavioral information 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 concise sentence that front-loads the usage condition and immediately states the input-output behavior. 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 the tool's simplicity, two parameters, and the presence of an output schema, the description adequately covers the purpose and behavior. No notable 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 0%, so the description must clarify the parameters. It mentions 'total and failed deployments', which maps to the two parameters. While not overly detailed, it provides sufficient meaning for the simple calculator context.

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 change failure rate and DORA tier. It is specific to this metric, but does not explicitly differentiate from the sibling 'dora-metrics-calculator', which might be broader.

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 when-to-use condition ('when a user asks about change failure rate or DORA CFR'), but offers no guidance on when not to use it or what alternative tools (e.g., dora-metrics-calculator) might be better for broader DORA analysis.

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 waste estimate and tier,' which is consistent with read-only behavior. There is no contradiction, and the description provides adequate 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?

The description is two sentences, front-loaded with the use case, and every sentence adds value. It is appropriately sized and free of redundant information.

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

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

Given the tool's simplicity (calculator with 4 parameters) and the presence of an output schema, the description covers essential context: purpose, inputs, and output type. It does not explain the calculation formula or tier logic, but the output schema likely provides sufficient detail.

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 mentions 'monthly cloud bill and idle/oversized percentages' and 'unattached storage,' covering all four parameters. While it does not detail constraints (e.g., percentages 0-100), the semantic mapping is clear and sufficient.

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

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

The description explicitly states the tool's purpose: 'Use when a user asks about cloud waste, idle resources, or unattached storage.' It mentions specific inputs (monthly cloud bill and idle/oversized percentages) and outputs (waste estimate and tier). This clearly distinguishes it from sibling calculators such as ec2-cost-calculator or egress-cost-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 a clear usage guideline: 'Use when a user asks about cloud waste, idle resources, or unattached storage.' It does not explicitly state when not to use it or mention alternatives, but the 'when to use' guidance is strong enough for an AI agent to decide.

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, so the description aligns. It adds that the tool returns cluster utilization and headroom, which is useful 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 two sentences: first sentence states the use case, second lists inputs and outputs. No redundant words, front-loaded with key info.

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

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

Given the output schema exists, the description's mention of return values is sufficient. It covers required parameters and gives an overview, though optional parameters are not fully elaborated. Overall adequate for invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains node_cpu, node_memory_gb, and pods in plain English, but pod_cpu_m and pod_memory_mb are only mentioned as 'resource requests' without units or clarification. This partial compensation results in a score of 3.

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

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

The description clearly states the tool's purpose: to check Kubernetes cluster capacity and how many more pods can be scheduled. It lists inputs and outputs, making it 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 explicitly says 'Use this when a user asks whether their Kubernetes cluster has enough capacity, or how many more pods they can schedule,' providing strong usage guidance. It lacks explicit exclusions or 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.

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

Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds that it returns recommended pool size per instance with utilization ratio, confirming no side effects. No contradictions.

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

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

The description is two sentences with no fluff. Usage guidance is front-loaded, followed by inputs and output. 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 tool's simplicity, the description covers the use case, inputs, and output. The presence of an output schema further reduces the need to detail return values. 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 description coverage is 0%, so the description must compensate. It lists the three parameters but does not explain their semantics (e.g., what cpu_cores means, default values for optional parameters). Partial compensation.

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 recommended connection pool size per instance, specifying use cases for configuring database connections or troubleshooting PostgreSQL connection exhaustion. It differentiates from sibling calculator tools by its specific domain.

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

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

The description explicitly says when to use the tool: when a user asks about connection pool configuration or troubleshooting PostgreSQL exhaustion. It does not mention when not to use or alternatives, but the context of sibling calculators makes it clear.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe read operation. The description adds no additional behavioral context (e.g., no mention of what the calculator does internally, any constraints, or side effects), so it fails to add value 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 concise sentence, which is efficient for length. However, it does not fully earn its place as it omits crucial parameter semantics and behavioral details, making it minimally informative despite its 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?

Given the presence of an output schema (covering return values) and the tool's specific purpose, the description remains incomplete. It lacks parameter descriptions, formula or methodology, and the relationship between inputs and outputs. The description alone is insufficient for an agent to correctly invoke the tool.

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

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

Schema description coverage is 0%, yet the description provides no explanation for the three parameters (team_size, working_days, deploys_per_month). It does not clarify their meaning, units, or how they relate to deployment frequency calculation, leaving the agent without essential context for correct parameter usage.

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 when to use the tool ('when a user asks about deployment frequency or DORA deploy cadence'), which effectively signals the intended use case. However, it lacks an explicit verb describing the action the tool performs (e.g., calculates, returns), slightly reducing clarity.

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 usage condition ('use when...'). However, it does not differentiate from the sibling 'dora-metrics-calculator', which may also handle DORA metrics, leaving ambiguity about when to choose this tool over 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 and destructiveHint=false. The description adds behavioral context: 'Returns findings with redacted matches and severity classification', 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?

Single sentence with no filler. Every word adds value: verb, input types, what it detects, and output summary.

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 one input, no nested objects, and an output schema exists. The description succinctly covers input, processing, and output format (redacted matches, severity). Complete for a simple scanner.

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 'text' with 100% schema description coverage. The description's mention of 'Config, code, or env file content' adds context but does not significantly extend the schema's own description. 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 uses a specific verb 'Scan' and identifies the resource 'text (config, code, env files)'. It clearly distinguishes from sibling tools (which are calculators/estimators/linters) by focusing on secrets detection.

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

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

The description implies use cases by mentioning 'config, code, env files', but lacks explicit when-to-use, when-not-to-use, or alternative tool guidance. Sibling tools are unrelated, so confusion is minimal.

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, indicating safe, non-destructive behavior. The description adds specific lint checks (e.g., :latest tag) and output format (issues with suggestions), providing behavioral detail 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 very concise—two sentences that immediately state the action and list specific checks. No unnecessary words, and the most critical information is front-loaded.

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

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

For a simple linter with one parameter and an output schema (though not shown), the description adequately covers what the tool does and what it returns. It could be slightly enhanced by noting that input must be valid Dockerfile content, but overall it 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?

The schema has 100% coverage for the single parameter (dockerfile), and the description does not add extra meaning beyond the schema's description ('Dockerfile content (full or partial)'). 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's purpose: linting a Dockerfile for common issues. It lists specific issues (e.g., :latest tag, interactive installs without -y, running as root) and mentions returning issues with suggestions per instruction. This distinguishes it from sibling tools, which are mostly calculators or checkers for other formats.

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 checking Dockerfiles but does not explicitly state when to use this tool versus alternatives like kubernetes-manifest-linter or other scanners. No guidance on prerequisites or exclusions is provided.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds that the tool returns tier classifications (Elite/High/Medium/Low) per metric, which is helpful behavioral context beyond the structured fields. 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?

Two sentences, front-loaded with use case, no redundant words. 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 complexity (4 parameters, 3 required, output schema exists), the description covers inputs, outputs (tier classification), and purpose. 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 0%, so description must compensate. The description names the four parameters but provides minimal semantic detail (e.g., 'deploy frequency', 'lead time hours'). It does not explain units or constraints beyond what the schema (type: number) provides. Baseline for 0% coverage is below 3, but the description adds enough to justify a 3.

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

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

Description explicitly states the tool's purpose: benchmarking engineering teams against DORA metrics and classifying deployment frequency and lead time. It clearly distinguishes from siblings like deployment-frequency-calculator or change-failure-rate-calculator, which focus on single metrics.

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 usage context ('when a user wants to benchmark...'). It does not explicitly exclude cases or mention alternatives, but the sibling tools suggest when a single metric might suffice. A more explicit 'when to use versus' would raise the score.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds that it returns two specific outputs (monthly cost, savings) but omits behavioral details like pricing source (on-demand?), region handling, or credential requirements. Adequate but not thorough.

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

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

Two sentences, front-loaded with usage, no redundancies. 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?

For a calculator tool with an output schema, the description covers main inputs and outputs. Siblings include other cost calculators, but the EC2+DO scope is unique. Missing some details (e.g., region sensitivity) but overall 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?

With 0% schema description coverage, the description must compensate, but it only mentions 'instance type and hours,' ignoring the 'os' parameter. Hours_per_month is described as optional but description implies it's needed. Missing parameter meaning reduces clarity.

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 and resource: 'use when a user asks about EC2 cost' and specifies output (monthly cost and DO-equivalent savings). Partially differentiates from sibling calculators by focusing on 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 a clear start condition. Does not mention when not to use or alternatives, but the positive guidance is strong.

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. The description adds that the tool uses 'AWS tiered pricing' to calculate the estimate, providing useful behavioral context 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?

Two sentences, each serving a purpose: first states usage intent, second defines input and output. No extraneous information. Front-loaded with when-to-use.

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 simplicity of the tool (one parameter, no nested objects, output schema exists), the description is complete. It covers input, output, and calculation basis. No additional information is necessary.

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 for `transfer_gb`. The description adds that it is 'monthly transfer volume in GB', which clarifies the unit and context beyond the schema's type definition. However, it does not specify allowed range or 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's purpose: estimating AWS data transfer costs based on monthly volume in GB. It uses a specific verb ('calculate') and resource ('AWS data transfer egress cost'), distinguishing it from sibling cost 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?

Explicitly states when to use the tool (when a user asks about AWS data transfer/egress costs or wants to estimate monthly bill). Provides the required input (monthly transfer volume in GB) but does not explicitly mention when not to use or list alternatives, though context from sibling names implies differentiation.

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 tool is safe and side-effect-free. The description adds output details (budget minutes, burn rate, status levels) but does not disclose behavior for missing optional parameters or default values. It is consistent 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 two sentences, front-loaded with usage guidance, and contains no extraneous information. Every sentence provides 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 low complexity and presence of an output schema, the description adequately covers core purpose and outputs. However, it omits explanation of optional parameters and their defaults, which limits completeness for agents needing to invoke with all inputs.

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 all parameters. It mentions 'SLO percentage and window' corresponding to slo_pct and window_days, but does not explain consumed_minutes or window_elapsed_days. This leaves two of four parameters undocumented.

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 calculates error budget, remaining budget, and burn rate from SLO percentage and window. It specifies outputs: budget minutes, burn rate multiplier, status. However, it does not distinguish from the sibling 'slo-burn-rate-calculator', which might overlap in functionality.

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 begins with 'Use this when a user asks about their SLO error budget...' which provides explicit context for when to use. It does not mention when not to use or provide alternative tools, but the guidance is clear for its intended purpose.

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. Description adds that the tool calculates and returns specific cost figures, confirming it's a read-only computation. No contradiction; description complements annotations by detailing output structure.

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 sentence states usage condition, second lists inputs and outputs. No redundant words, well front-loaded. 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 5-parameter calculator with output schema, description covers core required parameters and returns. However, it omits explaining optional parameters (eng_hourly, responders) which may be important for engineering cost calculation. Not fully complete but sufficient for basic use.

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

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

Schema coverage is 0%, so description must compensate. It mentions 'hourly revenue, downtime duration, and affected percentage' – covering 3 of 5 parameters. However, it omits 'eng_hourly' and 'responders', and does not provide units or format details. Adds some meaning but not full parameter documentation.

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

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

Description clearly states the tool calculates incident cost from outage/downtime. It specifies inputs (hourly revenue, downtime, affected percentage) and outputs (revenue impact, engineering cost, total cost). This distinguishes it from sibling calculator tools like alert-fatigue-calculator or apdex-score-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 'Use this when a user asks what an outage or incident cost' – clear context. Does not explicitly list alternatives, but the sibling tools are all different calculators, implying appropriate usage. Slight gap in not saying 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, idempotentHint, and destructiveHint. The description adds behavioral detail: it checks against a database and returns specific fields (status, CVE ID, severity). No contradiction; the description complements annotations well.

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

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

The description is two sentences, front-loads the action and database, and lists returns and examples efficiently. Every sentence adds value with no redundancy.

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

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

With a simple input schema, existing output schema, and annotations covering safety, the description is largely complete. It explains the tool's purpose and outputs. A minor gap: it does not mention whether the database is live or cached, but this is not critical.

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 parameter is fully documented. The description provides example package names but adds no new semantic meaning beyond what the schema already offers. 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 action ('Check'), the resource ('package name against a database of known CVEs'), and explicitly lists return values (vulnerability status, CVE ID, severity) with concrete examples. It is distinct from sibling tools, which are 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?

The description implicitly suggests usage for common packages by listing examples, which sets expectations on scope. It does not explicitly state when not to use or compare with alternatives, but the context is clear enough for the simple one-parameter 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 indicate readOnlyHint=True, idempotentHint=True, and destructiveHint=False, so the tool is safe. The description adds context about the checks performed and the return format (issue list and severity), which is helpful 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?

The description is a single, well-structured sentence that front-loads the purpose and lists specific checks. Every word adds value, with no redundancy or wasted space.

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 low complexity (single input, output schema exists), the description sufficiently covers the purpose, inputs, checks performed, and output format. No gaps are apparent.

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 has 100% description coverage for the single manifest parameter. The description does not add any new semantics beyond the schema, so it meets baseline expectations.

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 (YAML) for common issues like missing resource limits and health checks. The verb 'lint' and resource 'Kubernetes manifest' are precise, and the listed checks distinguish it from sibling linters like dockerfile-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?

The description explains what the tool does but does not explicitly state when to use it versus alternatives or when not to use it. The usage is implied by the name and checks, but no explicit guidance is provided, earning a mid-range score.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true, so the tool is safe and side-effect-free. The description does not add further behavioral context (e.g., permissions, rate limits, error handling) beyond the input format, so it scores a 3.

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

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

The description is two sentences with no wasted words. It front-loads the usage guidance and then explains the input format. Perfectly concise for the tool's simplicity.

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 low complexity (one parameter, simple input), annotations, and presence of an output schema, the description provides enough information to select and invoke the tool. It lacks details on error handling or return value format, but these are likely covered by the output schema, so it is nearly 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?

Input schema has 0% description coverage, so the description must compensate. It does so by explaining that 'incidents' can be a string of lines or an array of objects with specific keys. This adds significant meaning beyond the bare schema, earning a 4.

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 MTTR or DORA recovery time, specifying the verb (use when asks about) and resource (MTTR/DORA recovery time). It distinguishes itself from siblings by focusing specifically on MTTR rather than broader DORA metrics.

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: 'Use when a user asks about MTTR or DORA recovery time.' It provides clear context but does not include exclusions or mention alternatives like dora-metrics-calculator, so it scores a 4.

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 a safe, non-destructive operation. The description adds no additional behavioral context such as side effects, rate limits, or output format, failing to leverage the opportunity to enhance transparency.

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

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

The description is a single sentence with no fluff, making it concise. However, it is under-specified; it does not earn its place by providing substantive information beyond a usage hint. A slightly longer description with more detail would improve the trade-off.

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 4 required parameters with no schema descriptions and an existing (but unseen) output schema, the description is incomplete. It does not explain the calculation output or how inputs relate to the burden metric, leaving significant gaps for an agent to invoke correctly.

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

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

Schema description coverage is 0%, and the description does not mention any of the 4 parameters (engineer_count, shifts_per_month, hours_per_shift, hourly_cost). The description adds no meaning beyond the schema's basic names, leaving the agent without guidance on how to use each parameter.

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 says 'Use when a user asks about on-call load or burnout risk,' which implies a usage scenario but does not explicitly state what the tool does (e.g., calculates a burden score). The name clarifies it is a calculator, but the purpose is vague compared to siblings like 'alert-fatigue-calculator' which have similar descriptions.

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 single usage context ('when a user asks about on-call load or burnout risk') but does not mention when not to use the tool or suggest alternatives among the 31 sibling calculators. No exclusions or comparisons are 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that it returns monthly billing cost with runner multiplier breakdown, which 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?

Two clear sentences: first states when to use, second lists inputs and output. No wasted words, highly concise.

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

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

Output schema exists (not shown, so presumably documented elsewhere). Description covers core function, inputs, and output adequately for a calculator 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% description coverage; description mentions 'runner type' but does not explain values for runner, nor details on avg_job_min, jobs_per_run, runs_per_month beyond their names. Adds some context but insufficient for full parameter understanding.

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

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

Description clearly states it calculates monthly CI/CD pipeline costs and compares runner costs. Distinguishes from siblings like ec2-cost-calculator by focusing on GitHub Actions CI/CD pipelines.

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

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

Explicit usage context: 'Use this when a user asks how much their GitHub Actions CI/CD pipeline costs per month, or wants to compare runner costs.' No exclusion of alternatives, but generally 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 indicate read-only, idempotent, non-destructive behavior. Description adds that it returns interpretations, which is useful 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?

Three sentences, no extra words. Front-loaded with usage instruction. 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 output schema exists, description properly omits return structure details. It covers when to use, inputs, and outputs (F1, F-beta, interpretation). Could mention edge cases (e.g., zero precision+recall) but not essential.

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 coverage, description only names parameters ('precision, recall, optional beta weight') without explaining semantics (e.g., range, interpretation of beta). This is adequate for self-documenting names but adds minimal value.

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

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

Description explicitly states the tool calculates precision, recall, F1, and F-beta for ML models. It clearly distinguishes from sibling calculators which target other domains (e.g., alert fatigue, Apdex).

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?

Sentence 'Use this when a user asks about their ML model precision, recall, F1 score, or F-beta score' directly specifies when to use. No explicit exclusion or alternatives, but sibling tools are distinct enough.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows it's safe. The description adds detail on the heuristic analysis factors and output (cost score and level), enhancing transparency 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 a single sentence with a concise list of factors, no redundancy, and front-loaded key 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?

The description covers purpose, analysis factors, and output. An output schema exists, so omission of exact score scale is acceptable. Slightly lacking in specifying the range or interpretation of the cost score, but generally complete 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 coverage is 100% and the parameter description ('SQL query to analyze') is sufficient. The tool description does not add further semantics for the parameter beyond the schema, so baseline score applies.

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

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

The description clearly states it estimates relative cost of a SQL query using heuristic analysis, listing specific factors like SELECT *, JOIN count, etc. This distinguishes it from sibling tools, which focus on different cost estimation 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 usage for SQL query cost estimation but does not provide explicit guidance on when to use vs. alternatives or when not to use. No context or exclusions are 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 declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds value by detailing output fields (utilization percentage, buffer, safety status, risk level) and specific thresholds (OK/WARNING/CRITICAL), which are not in 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 is two efficient sentences, front-loaded with the core purpose, and each sentence provides necessary information without redundancy.

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

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

Given the tool's simplicity and the presence of an output schema (as per context signals), the description covers key aspects: input parameters (though missing window_seconds) and output structure. Minor omission of window_seconds prevents a perfect score.

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

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

Input schema has 100% coverage with descriptions for all parameters. The description mentions 'current request count and limit' but does not discuss the optional `window_seconds` parameter, which is documented in schema. Thus, description adds minimal semantic value 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?

The description clearly states the tool calculates API rate limit utilization given current request count and limit, using a specific verb and resource. It distinguishes from sibling calculators by focusing on rate limiting, which is unique among the listed sibling tools.

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

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

The description provides clear context for when to use the tool (when rate limit utilization is needed) but does not explicitly mention when not to use it or suggest alternative tools. The purpose is clear enough to avoid confusion with different calculators like error-budget-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=true and idempotentHint=true, so the tool is safe and idempotent. The description adds that it returns break-even month and net savings, which is consistent but does not significantly extend beyond annotation 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?

Description is two sentences, front-loaded with usage guidance. It is efficient but could be slightly more concise by combining sentences. Still, it earns its space without fluff.

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

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

Despite having an output schema, the description lacks sufficient context for 5 parameters with 0% schema coverage. It does not specify units, required vs optional parameters, or assumptions (e.g., currency, time horizon). This incompleteness harms usability 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 description coverage is 0%, so the description must compensate. It mentions 'On-Demand and RI monthly costs plus upfront fee,' but does not clarify which parameters are required (only three are required, upfront fees are optional), nor does it explain units or constraints. This vagueness may lead to incorrect parameter invocation.

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: to answer whether to buy Reserved Instances or stay on On-Demand, and compute break-even month and net savings. It specifies inputs and outputs, making it distinct from sibling calculators like ec2-cost-calculator or total-cost-of-ownership-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 ('when a user asks whether to buy Reserved Instances...'), but does not mention when not to use or provide alternatives among many sibling calculators. Still, the context is clear and not misleading.

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, idempotentHint=true, so the description does not need to repeat these. However, the description adds no additional behavioral context (e.g., what the output contains or any side effects). With annotations present, a score of 3 is appropriate as the description provides minimal extra value.

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, front-loaded with the usage directive. There is no fluff or redundant information. It is perfectly concise for its content.

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 6 parameters (4 required) and no parameter descriptions, the description is too minimal for a calculator tool. The presence of an output schema reduces the need to explain return values, but the lack of parameter guidance and behavioral detail makes the tool hard to use correctly without external knowledge.

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 parameter. While the term 'rightsizing' hints at the parameters (current_vcpu, p99_cpu_pct, etc.), no explicit semantics are added. Given the high parameter count (6) and no descriptions in schema, the description fails to compensate.

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 instance rightsizing and overprovisioned compute. It uses specific verb 'rightsizing' and resource 'compute'. However, it does not distinguish this from sibling calculators like cloud-waste-calculator or ec2-cost-calculator, which could also involve compute optimization.

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 instance rightsizing or overprovisioned compute,' providing clear context. Lacks guidance on when not to use or alternatives, but the single-sentence directive is sufficient for basic 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 read-only, idempotent, and non-destructive behavior. The description adds what the tool computes and returns (burn rate multiple, time-to-exhaustion signal), providing 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: first states when to use, second states inputs and outputs. No redundant information, front-loaded with purpose, concise and structured effectively.

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 simple numeric parameters and an output schema, the description covers the core functionality. It mentions the outputs (burn rate multiple, time-to-exhaustion) and usage context. However, it omits details like the meaning of slo as a percentage threshold and the implicit period assumption, which could be clearer.

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 maps 'error count' to errors and 'total requests' to total, but does not explain the slo parameter meaning (the SLO target) or clarify that errors and total are counts over a period. Partial explanation, but not complete.

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

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

The description explicitly states the tool's function: computing burn rate multiple and time-to-exhaustion given error count, total requests, and SLO target. It uses specific verb+resource ('calculate burn rate') and differentiates from sibling tools like error-budget-calculator by focusing on rate, not remaining budget.

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 opens with 'Use this when a user asks how fast they are burning their error budget' providing clear usage context. It does not explicitly mention when not to use it or suggest alternatives, but the scenarios are well-defined.

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 no further behavioral context beyond what annotations provide. It does not contradict annotations, but also does not add value (e.g., no mention of requiring authentication or output characteristics).

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 extraneous words. It is front-loaded and efficient.

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

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

Given 8 parameters with no schema descriptions and no parameter guidance in the description, the tool is under-described. The existence of an output schema is not leveraged in the description. The agent lacks information on required inputs or expected 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 8 parameters with 0% description coverage. The description does not explain any parameter's meaning or purpose. Although parameter names like 'numUsers' and 'monthlySubscription' are somewhat self-explanatory, a score of 1 is warranted due to total lack of semantic guidance.

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 calculating risk of software purchases or SaaS commitments. This verb+resource pair is specific and distinguishes it from sibling calculators, though it does not elaborate on the nature of the risk (e.g., financial, security).

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 basic when-to-use condition ('when a user asks about risk of a software purchase'), but lacks when-not-to-use instructions or alternatives. Among sibling tools, none directly address software purchase risk, so implicit differentiation exists, but no explicit guidance 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 declare the tool as read-only, idempotent, and non-destructive. The description adds 'estimate monthly cost', consistent with annotations but does not disclose additional behaviors like rate limits or auth needs. With annotations covering safety, a score of 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 sentence, concise and direct. However, it sacrifices completeness for brevity. Given the tool's simplicity, it is reasonably sized, but could include a brief parameter hint without being verbose.

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 3 parameters (2 required) and no schema descriptions, the description lacks essential parameter guidance. The output schema exists but is not referenced. For a complete agent decision, more detail is needed.

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 parameter meanings. The fields resource_type, count, and instance_size are not explained, leaving the agent without guidance on how to fill them. This severely hinders correct usage.

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

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

The description explicitly states the tool estimates monthly cost of a Terraform plan, using a specific verb and resource. It distinguishes from siblings like ec2-cost-calculator or query-cost-estimator by specifying 'Terraform plan'.

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

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

The description gives a clear when-to-use condition: when user asks for monthly cost of a Terraform plan. It doesn't provide when-not-to-use or explicit alternatives, but the sibling list implies other cost estimators for other contexts.

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 tool's safety is clear. The description adds no behavioral details beyond this, but does not contradict. Minimal added value.

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, concise but under-specified. It front-loads the purpose but omits essential details for a tool with many parameters. The structure is too simple for the tool's complexity.

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 8 parameters, 0% schema coverage, and the presence of an output schema, the description is severely incomplete. It does not explain input meaning, calculation behavior, or output structure, leaving agents with insufficient information.

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%, yet the description fails to explain any of the 8 parameters, including the 2 required ones. Without any parameter guidance, the description provides no help for correct invocation.

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 calculations. However, it does not distinguish it from other cost calculators like ec2-cost-calculator or reserved-instance-breakeven. The verb is implied but not explicit.

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 a single condition: 'when a user asks about TCO or multi-year SaaS cost.' No exclusions, alternatives, or prerequisites mentioned. Offers basic context but minimal guidance.

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