Model Ruler — AI Cost Calculators

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

Annotations already declare a safe, idempotent, closed-world read-only computation, so the safety profile needs no restating. The description adds real modeling context (failure overhead and context growth across turns affect the total), but says nothing about output units, currency, or the shape of the returned breakdown. Minor but genuine added value over structured fields.

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 tightly packed sentences: the first establishes what it computes and the cost factors included, the next two route to alternatives. Zero filler and the purpose is front-loaded ahead of the disambiguation clauses.

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 nine-parameter, annotation-covered pure calculator with no output schema, the description covers what it computes and how it relates to siblings. The one gap is that it never hints at what the result contains (e.g., per-task cost, monthly total, currency), which matters for a tool with no 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 description coverage is 100% with all nine parameters, defaults, and ranges documented in the schema, including success_rate, steps_per_task, and context_growth_factor. The description adds no parameter-level detail beyond that, so the 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 states a precise verb and resource: cost calculation for LLM inference/reasoning per successful multi-step agent task, explicitly scoped to include failure overhead and context growth. It also names the two sibling calculators it is not, so an agent can disambiguate without opening any schema.

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

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

It gives explicit routing rules: use agent-workflow-cost-calculator for iPaaS/app-action/MCP orchestration fees, and automation-cost-calculator for generic Zapier/Make/n8n workflow billing. The alternatives and the conditions that select them are named directly, leaving nothing to inference.

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 establish this as a safe, read-only, idempotent computation, so the description only needs to add scope. It usefully discloses the cost boundaries — includes app-action fan-out and MCP tool calls, excludes LLM token spend — which materially affects interpretation of the result. It does not state units, currency, or output shape, so it falls short of a 5.

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 tight sentences, front-loaded with the core purpose, then the two exclusions/routes. Every clause carries routing or scoping information with no filler.

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 deterministic calculator with full schema coverage and annotations covering the safety profile, the description supplies everything needed to select and invoke it correctly. The only minor gap is that it never indicates what the returned cost value looks like or its units, and no output schema exists to fill that in.

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 all four parameters (including defaults for app_actions_per_run, make_modules_per_run, mcp_tool_calls_per_run) are documented inline. The description's mention of app-action fan-out and MCP accounting reinforces but does not extend the schema, so the 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?

States a specific verb (cost calculation) and resource (automation-platform/iPaaS spend for an AI agent workflow), and scopes it precisely with what is included (app-action fan-out, MCP tool-call accounting) and excluded (LLM token spend). This immediately separates it from its siblings without opening any schema.

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 names two alternatives with the condition that selects each: 'automation-cost-calculator for generic non-agent workflow billing' and 'agent-loop-cost-calculator for LLM inference/reasoning cost'. This is textbook when-to-use/when-not-to-use routing.

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, and openWorldHint=false, so the safety and determinism profile is fully covered by structured data. The description adds scoping context (which billing models are in scope) but says nothing about the returned output, assumptions, or platform-specific billing edge cases. With annotations carrying the behavioral burden, this is adequate but not additive.

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, all routing-oriented, with zero filler. The scope statement comes first, followed by the two exclusion/alternative conditions in a consistent 'Use X instead when Y' pattern that 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?

There is no output schema, so the description is the only place return values could be described, and it omits what the calculator actually returns (presumably per-platform cost breakdowns given the multi-platform scope). Routing is otherwise complete for a read-only deterministic calculator, so the gap is minor but real.

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

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

Schema description coverage is 100%, so all three parameters (workflow_runs_per_month, billable_steps_per_run, make_modules_per_run) are already documented in the schema, including defaults and the Make fallback to billable_steps_per_run. The description adds domain framing around billing models but no parameter-level meaning beyond what the schema provides, so the baseline of 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 states a specific function (recurring workflow platform billing cost calculation) and enumerates the exact billing models covered: Zapier task billing, Make credit billing, and n8n execution billing. It explicitly differentiates itself from two named siblings, so an agent can identify it without opening any schema.

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

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

It gives an explicit when-to-use condition ('generic or non-agent recurring workflow platform billing'), then names agent-workflow-cost-calculator for AI-agent workflows with app actions/MCP calls and agent-loop-cost-calculator for LLM inference/reasoning cost per successful task. Both alternative routes and their selecting 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered and the description does not contradict it. However, the description adds no behavioral context beyond that (e.g., that results are deterministic estimates rather than billing guarantees), so it earns only the baseline.

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 front-loaded sentence with zero filler; the two trigger conditions come before the parenthetical strategy list, so the most important routing information is read first.

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 five well-documented parameters, full annotations, and no output schema, the description is nearly self-sufficient: it signals both the fit-check and the strategy-recommendation outputs. It could be stronger by clarifying that results are token-budget estimates, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is 100%, with every parameter including defaults (overhead 2000, output 1000) and the enum documented in the schema itself. The description merely restates the concepts of document, prompt, and output and repeats the four strategy names, adding no syntax or semantic detail 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 names a concrete capability: determining whether document+prompt+output fit a model's context window and recommending a strategy. That is a specific verb-and-resource statement, but it never distinguishes this tool from close siblings like token-counter or rag-pipeline-cost-calculator, which an agent could easily confuse it with.

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

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

It gives two explicit triggering conditions ('needs to know whether ... fits' and 'wants a strategy recommendation'), which is clear when-to-use guidance. It offers no when-not or named alternative, so it falls short of full routing 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 readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds value the annotations cannot: it enumerates the return shape (total cost, per-run cost, parallel time estimate), which matters because there is no output schema. It does not disclose the pricing assumptions or data source behind the estimate, which is the remaining 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?

Two sentences, zero filler, and the usage condition is front-loaded ahead of the output summary. Nothing repeats the name or title verbatim.

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 no output schema, the description's mention of the three returned values is genuinely load-bearing, and the schema fully covers inputs. Minor gap: it never says how costs are derived (pricing table, assumption of defaults), which matters for a budgeting tool whose accuracy depends on those assumptions.

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 10 documented parameters, including defaults for model, tokens, judge settings, and trials. The description only gestures at samples/models/trials without adding syntax or units beyond the schema, so the 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?

States a specific verb+resource (calculate the cost of an LLM evaluation run) and scopes it tightly enough to separate it from siblings like rag-pipeline-cost-calculator and agent-loop-cost-calculator. It even names the outputs (total cost, per-run cost, parallel time estimate), so the agent knows exactly what comes back.

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?

"Use when a user needs to budget an LLM evaluation run" gives a clear triggering condition, which is more than most siblings offer. It stops short of naming alternatives (e.g., 'use provider-cost-calculator for raw token pricing'), so no exclusion guidance is present.

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 and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds the return-value set (ROI, breakeven volume), which is useful given no output schema, but says nothing about assumptions, defaults, or how optional inputs behave.

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, zero filler. The usage condition is front-loaded and the output list follows immediately, so an agent can skim it in one pass.

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 no output schema, the description usefully enumerates the four returned values, which is the key missing structured information. It is still silent on defaults for optional inputs (e.g. prompt_reduction_pct default 0) and on how missing cost parameters are resolved.

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 six parameters, each documented with units and role, so the schema carries the semantic load. The description adds no parameter-level detail beyond that, which is the expected baseline when the schema is 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 names a specific decision ('fine-tuning vs prompt engineering') and enumerates the concrete outputs (training cost, monthly inference savings, months-to-ROI, breakeven volume), so the agent knows exactly what the tool produces. It does not differentiate itself from the many sibling *-calculator tools, which is the main gap.

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?

'Use when a user is considering fine-tuning vs prompt engineering' is an explicit usage trigger tied to a user intent. There is no guidance on when to prefer the sibling tools (e.g. provider-cost-calculator or agent-loop-cost-calculator) or when not to use this one.

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 readOnly=true, idempotent=true, openWorld=false, destructive=false, so the safety profile is covered. The description adds that the output is a monthly figure adjusted by retention, which is modest but useful context; it does not disclose pricing-model assumptions or whether cost is per-provider.

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 tight sentences with the use case front-loaded and the return value second. Nothing is wasted, though the second sentence slightly overlaps what the schema already implies.

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 no output schema, the description correctly states the headline return value (monthly cost at a given volume with retention adjustment), which is enough to call the tool. Minor omission: it never notes that only one provider is evaluated per call.

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

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

Schema description coverage is 100%, so the enum provider list, default avg_log_bytes (4096), default retention_days (30), and requests_per_day are already fully documented. The description references request volume and retention but adds no format or unit detail 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?

States a concrete verb and resource: it budgets "LLM observability tooling" and returns a monthly cost. The 'observability' scope does distinguish it from eval-, agent-loop-, and rag-pipeline-cost siblings, though no sibling is named explicitly.

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?

"Use when a user needs to budget LLM observability tooling" gives a clear triggering scenario, but with 11 cost-calculator siblings there is no when-not guidance and no routing to alternatives such as provider-cost-calculator or eval-cost-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 declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds real behavioral value by disclosing the return content (monthly cost plus a tier comparison table), which matters because there is no output schema. It does not mention default assumptions for optional inputs beyond include_comparison, but the added context is meaningful.

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, zero filler, front-loaded with the 'Use when' trigger followed immediately by the input-to-output contract. Every clause 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?

With no output schema, the description must convey what comes back, and it does (monthly cost plus tier comparison table). All six parameters are fully documented in the schema and the safety annotations are complete, so nothing an agent needs to invoke this correctly is missing.

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

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

Schema description coverage is 100% and each of the six parameters is documented inline with units and examples ('Input tokens per call', 'Monthly call volume'), so the schema carries the load. The description only restates tokens-per-call and call volume at a high level and adds no syntax or default detail beyond what the schema provides, matching the 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?

States a specific verb and resource: given tokens per call and call volume, it returns monthly cost plus a tier comparison table. Distinguishes itself implicitly from siblings like rag-pipeline-cost-calculator or agent-loop-cost-calculator by targeting a raw provider/model workload, but it never names or contrasts those alternatives explicitly, so the differentiation is left to inference.

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?

Gives clear triggering conditions: 'when a user asks what an LLM workload costs on a specific provider/model, or wants to compare cost across providers.' That is a solid when-to-use statement, but it offers no when-not guidance and does not route the agent to or away from any of the ten sibling calculators that also compute cost.

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, and openWorldHint=false, so safety is covered. The description adds useful output context by naming the three returned estimates, though it does not describe calculation assumptions or limitations.

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

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

Two sentences, front-loaded with the usage condition and followed by the return values. Every sentence carries useful information without waste.

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

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

Although there is no output schema, the description enumerates the return values (VRAM, speedup, quality delta), and the input schema fully details all five parameters. This is sufficient for an agent to invoke the calculator 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%, so parameter meanings are fully documented in the schema. The description only alludes to parameter count and precision transition, which adds little beyond what the schema already provides.

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

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

The description states a specific calculation: given parameter count and precision transition, it returns VRAM, speedup, and quality delta. This clearly distinguishes it from sibling cost and planning 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?

It explicitly gives the use case: when a user is planning to quantize an LLM to fit on smaller hardware. However, it does not mention when not to use it or name any alternative tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine value beyond that by disclosing the return shape (monthly cost with breakdown and dominant-component identification), which matters since no output schema exists.

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, both load-bearing: the first gives the usage trigger, the second gives the return semantics. Front-loaded and free of filler.

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 an 11-parameter, no-output-schema calculator, the description covers the trigger and the returned artifacts (total cost, breakdown, dominant component), which is the essential missing piece. It omits currency/units assumption and any note on how pricing tables are sourced or how current they are, leaving minor gaps.

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

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

Schema description coverage is 100% across 11 parameters, so the schema already documents defaults, enums and units for each field. The description's "embedding + vector store + generation" phrasing loosely frames the three modeling dimensions but adds no syntax, default or constraint detail beyond the schema. 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 states a specific verb (cost estimation) and resource (end-to-end RAG pipeline, spelled out as embedding + vector store + generation), which cleanly separates it from siblings like provider-cost-calculator or token-counter by scope. It does not, however, name any sibling it should not be confused with, so it stops short of full differentiation.

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

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

"Use when a user needs end-to-end RAG cost estimation" is an explicit trigger condition, which is better than implied usage. There is no when-not guidance or pointer to alternative calculators (e.g. self-host-breakeven-calculator) for adjacent questions, so exclusions are missing.

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=false, so the safety profile is covered. The description adds real value by disclosing what the tool returns: breakeven token volume, monthly cost comparison, and a go/no-go recommendation. No output schema exists, so this return-value disclosure is meaningful, though determinism/edge-case behavior isn't discussed.

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 tightly written sentences with zero filler: the first states when to use it, the second states what it returns. Information is front-loaded and every clause 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 six-parameter calculation tool with annotations covering the safety profile and a schema fully documenting inputs, the description is nearly sufficient. It even compensates for the missing output schema by summarizing the return values. Minor gap: no mention of requiring any upstream inputs (e.g., current API cost) as prerequisites.

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

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

Schema description coverage is 100%, so all six parameters (gpu_type, gpu_provider, monthly_tokens, utilization_pct, api_cost_per_1m_out, operational_overhead_pct) are documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the 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 states a specific decision-support purpose: comparing API usage vs self-hosted GPU inference at a given volume. It's clear what the tool does, and the name reinforces it. However, it doesn't explicitly differentiate from cost-adjacent siblings like fine-tune-roi-calculator or provider-cost-calculator, so it stops short of a 5.

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?

"Use when a user is deciding between API usage and self-hosted GPU inference at a given volume" gives a clear triggering condition with a stated scope. It stops short of naming alternative tools for adjacent cost questions, so no explicit when-not or alternative routing.

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 establish readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description usefully adds that the result is a low/high range plus byte-level measurements rather than a single exact number, which an agent cannot learn from the annotations or schema.

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

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

Two sentences, front-loaded with the usage trigger followed by the input/output summary; no filler. Slightly dense but every clause carries 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?

With no output schema, the description does the necessary work of describing the return (range + byte measurements) and the safety profile comes from annotations. It leaves unclear how expected_out_tokens influences the result, a minor gap for a 3-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 description coverage is 100%, so every parameter is already documented with types, an enum, and a default. The description only echoes "text and tokenizer family" and omits any mention of expected_out_tokens, so it adds little beyond the schema. 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 names a specific action (count tokens for given text) and resource (text + tokenizer family), and states the return shape (low/high token range, byte-level measurements). It also draws the boundary with the sibling cost-calculator tools by framing itself as the pre-pricing sizing step.

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?

"Use when a user asks how many tokens a given text will consume, or needs to estimate prompt size before pricing a workload" gives a clear triggering context. There is no explicit when-not condition and no sibling tool is named as the alternative for adjacent cases (e.g. the cost calculators).

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