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

The description discloses important behavioral details beyond annotations: effective_usd is null when cache pricing is unavailable, nominal_usd acts as an upper-bound, and one row corresponds to one assistant reply. It does not contradict annotations, and while it omits rate limits or error behavior, the null-value semantics add meaningful context.

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

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

The description is compact and front-loaded, with each clause serving a purpose: output type, data fields, null semantics, source, alternative tool, and a usage tip. No wasted words or redundancy.

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

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

Given no output schema, the description adequately summarizes the return shape (per-inference fields and row semantics). It also covers the null-cost edge case and sourcing, though cwd remains undocumented and pagination/limits are not addressed, keeping it from a 5.

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 and two optional parameters, the description gives partial guidance by explaining that omitting session_id targets the most recent session. However, cwd is not explained at all, leaving a gap in 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?

The description opens with 'Raw JSON per-inference breakdown' and enumerates specific data fields (token counts, tool usage, cost, cache hit ratio, duration), making the tool's purpose unmistakable. It also distinguishes itself from render_consumption_report by explicitly naming the pre-formatted alternative.

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 clearly suggests when to use this raw JSON tool versus the pre-formatted render_consumption_report, and gives a practical usage hint about omitting session_id for the most recent session. It does not broadly enumerate all alternatives, but the key alternative is named and 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 declare idempotentHint=true and destructiveHint=false, so no contradiction. The description adds substantial behavioral detail beyond annotations: the basis of current_model_cost, the direct comparability of base_usd_cost and billed_usd_cost, the counterfactual rung policy, the semantics of usage.prompts/inferences/tool_calls, and the null behavior of effective_usd when cache pricing is unavailable. This is rich 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 core purpose and primary alternative are front-loaded in the first sentence. The remaining sentences are dense but each addresses a real ambiguity: cost basis, counterfactual pricing, usage counters, null behavior, source, and invocation shortcut. It could be restructured with bullets, but no sentence is purely 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?

With no output schema, the description carries the burden of explaining return semantics, and it does: it names the key fields, explains counterfactual row pricing, defines usage counters, and notes null behavior. It misses cwd semantics and profile classification details, but these are not blockers for invoking the tool since both parameters are optional.

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% and cwd has no description at all. The only parameter behavior described is session_id, which is optional and omitted for the most recent session. The description does not explain what cwd means, how session_id is formatted, or how the two interact, so it fails to compensate for the absent schema 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?

The description opens with a specific verb and resource: 'Raw JSON session analysis' and enumerates the outputs: token totals, effective/nominal cost with cache breakdown, counterfactual across every model, and profile classification. It clearly differentiates itself from the sibling render_session_report by noting this is raw JSON while that is pre-formatted output.

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 routes to an alternative: 'For pre-formatted output use render_session_report.' It also gives invocation guidance: 'Omit session_id for the most recent session.' It does not fully distinguish when to use compute_compare or analyze_inferences instead, but the raw-versus-formatted distinction is clear and actionable.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description goes far beyond them: it discloses that cache tokens are charged at full input rate, explains rung selection with over-half-open ranges, defines null max_input_tokens behavior, and states that an unreadable catalog errors the tool rather than quietly underestimating. This is rich behavioral context that the annotations alone do not 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 long, but every sentence carries domain-critical information about pricing ladders, cache handling, and error behavior. It is front-loaded with the core purpose and then systematically covers edge cases. A slight structural improvement (e.g., paragraphs or bullets) would help, but no sentence is 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?

For a complex tool with no output schema, the description covers the return shape ('sorted list plus a grouping by family'), parameter behavior, error semantics, and coverage boundaries. It even explains the no-special-case single-rung situation. There is no missing piece an agent needs to invoke the tool correctly, except for a trivial clarification of output_tokens' role in cost, which the name covers.

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 script covers input_tokens in depth: it is the whole input side, cache tokens count toward rung selection, and leaving them out quotes a rung too low. This meaningfully extends the schema description. However, output_tokens receives no explanation in the tool description beyond its name and example, so the 50% schema coverage gap is only partially compensated.

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

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

The description opens with a specific verb and resource: 'Rank every model in the current SCU index by nominal cost for a workload.' It also names the primary use cases ('which model is cheapest?') and explicitly contrasts with the sibling compute_estimate ('Covers index members only — for any other tracked model use compute_estimate'), so an agent can disambiguate without inspecting other schemas.

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 explicit when-to-use guidance and routes elsewhere: 'Use to answer...' and 'for any other tracked model use compute_estimate.' It also states the data source (Oracle API) and what index membership means, leaving no ambiguity about scope or 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 mark it read-only, idempotent, non-destructive; the description adds substantial context: provenance meanings, cache tokens charged at full rate and no discount, rung selection semantics, max_input_tokens behavior with refusal-before-provider, error on unreadable catalogue, and that prices hold as of operator's last pass rather than live. No contradiction with annotations.

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

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

The description is long but front-loads the core purpose and then systematically covers edge cases. Some elaboration (e.g., the full ladder explanation) could be tightened, but every sentence contributes to correct invocation. Verbosity is justified by 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?

With no output schema, the description fully explains return fields (base_usd_cost, routing_fee_usd, billed_usd_cost, routing_fee_rate, provenance, applied_context_tier, exceeds_max_input_tokens, price_source) and error behavior. It also covers reasoning tokens, cache handling, and closed alternatives, leaving no obvious gap for an agent to call the tool 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?

Even with 67% schema coverage, the description adds critical meaning: input_tokens includes cache reads/writes and affects rung selection; output_tokens includes reasoning tokens (no separate leg); model accepts bare names and warns about vendor slug mismatches. This goes well 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 opening sentence states a specific verb and resource: 'Nominal USD cost for any oracle-tracked model given input/output token counts'. It distinguishes itself from siblings like data_get_price (price lookup) and analyze_session (applies cache discount), and explicitly states 'Compare models on base_usd_cost; budget on billed_usd_cost'.

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

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

Explicitly names alternatives and conditions: 'For a cost with the cache discount applied, use analyze_session on a real transcript' and 'read the model's reasoning price from data_get_price'. Also gives practical advice on model id construction ('pass an id the API returned rather than assembling 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?

Beyond the readOnly/idempotent annotations, the description discloses key behavioral traits: the value is captured set-once and never changes, it returns null until the first revision is confirmed, and it includes the exact formula relating baseline to published computeIndex values. This is rich, non-obvious context that annotations alone would not convey.

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?

Although the description is longer than typical, every sentence earns its place: definition, immutability, source, formula, null behavior, and return schema. It is information-dense but well-structured, with no filler or redundant 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?

The description includes the complete Oracle response schema, explains the null state, provides the calculation formula, and covers the lifecycle ('set-once'). Despite having no formal output schema, the description fully compensates and leaves no material ambiguity about the tool's behavior.

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

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

The tool accepts no parameters, which is the baseline 4 case. There are no parameter semantics to clarify, and the description adds full clarity by explaining what the baseline represents and how it is sourced.

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 precisely identifies the tool as the frozen SCU denominator (baseline) for the computeIndex inverse purchasing-power view, using methodologyVersion 1 and set-once semantics. This clearly distinguishes it from sibling tools like data_get_scu or data_get_scu_at, which return current or point-in-time values.

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 provides clear context on when this tool is relevant—as the immutable baseline in the computeIndex formula—and notes the null-before-first-revision behavior. It does not explicitly name alternatives or state when not to use it, but the description makes the specialized role evident.

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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds substantial behavioral context: provenance marks and their meaning, null semantics for billed_*, context_tiers, max_input_tokens, and the fact that prices are live catalogue figures identical to data_get_price. It also clarifies that 'above a declared window the request is refused before it reaches the provider.' No contradiction with annotations.

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

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

The description is long but every sentence carries essential information about the complex return structure. It is well-organized: it starts with the main content (models and pricing), then explains provenance, context tiers, null semantics, and finally alternatives. No fluff; it is dense and purposeful.

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 returns a complex data structure with no output schema and no parameters, the description must carry the full burden of explaining the output. It covers all fields, null behaviors, provenance semantics, context tier ladder rules, and comparison guidance. Nothing an agent needs to interpret the response 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?

The tool has zero parameters, so the baseline is 4. The input schema is empty, and the description doesn't need to elaborate on parameters. However, it does not add any parameter-specific meaning (there are none), so the baseline score stands. It could arguably be a 5, but since there is nothing to explain, 4 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 states precisely what the tool returns: every model in the current SCU index with pricing, provenance, context tiers, and related metadata. It distinguishes itself from siblings by explicitly naming data_get_price (single model) and data_get_cpi (on-chain attested), making the scope unambiguous.

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

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

The description gives explicit guidance on when to use this tool versus alternatives: 'For a single model, use data_get_price instead' and 'For the prices a published index revision attested on-chain ... use data_get_cpi.' It also advises 'Compare models on base_*; budget on billed_*.' This leaves no ambiguity about selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds real value beyond this: the modelKey format caveat (bare manifest key, must strip vendor prefix before joining), the data source endpoint (/v1/oracle/scu.breakdown), and the discriminated-union keyed-by-methodologyVersion structure. No contradiction with annotations; it enriches them.

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

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

The core purpose is front-loaded in the first clause and the modelKey warning, source, usage, and sibling alternative each earn their place. It is dense and includes a large inline Oracle response schema that bulks the description considerably, but no sentence is wasted and the technical warnings are genuinely necessary.

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 available, the description must convey the return contract, and it does — enumerating every field, the union keying, the modelKey normalization rule, and the source. For a 0-parameter read-only tool this is complete enough for an agent to invoke and interpret correctly. The embedded schema further bolsters completeness.

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

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

The tool takes zero parameters, so the baseline is 4. The description does the heavy lifting of explaining the return shape — the union keyed by methodologyVersion and the five fields per family representative — which is the semantically meaningful content here. It compensates fully for the absence of parameters.

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 (get) plus a precise resource: the per-family blended-cost breakdown of the SCU, a methodology-versioned discriminated union. It names the distinguishing content (one entry per family representative with five explicit fields) and explicitly differentiates from the sibling data_get_scu, so an agent can tell the two apart without opening either 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?

Gives an explicit use case ('attribute SCU contributions to specific model families') and an explicit when-not/alternative ('For the full SCU response with reference workload, use data_get_scu instead'). This routes the agent decisively between the two SCU tools, 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, and the description adds substantial behavioral context: provenance marks are trust ratings, not charge modifiers; values bill exactly as shown and hold as of the operator's last pass rather than a live vendor check; the document is passed through unchanged; missing maxInputTokens means no per-model limit but the request-body ceiling still applies. No contradiction with annotations.

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

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

Although the description is long, it is dense and front-loaded: the first sentence states the purpose, the next gives the source, then field semantics, provenance rules, behavior, and alternatives. Every clause earns its place, and the embedded response schema is justified by the lack of a separate output schema.

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

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

For a zero-parameter read-only catalog tool, the description is remarkably complete: it explains scope, source, per-field semantics, provenance meanings, absence semantics for contextTiers and maxInputTokens, billable behavior, and sibling routing. The embedded OpenAPI-derived schema further covers the return structure. Nothing necessary for correct invocation appears to be 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?

The tool has zero parameters and an empty input schema, so parameter semantics are not applicable. The description appropriately spends its effort explaining the output shape and field meanings instead. Baseline 4 for a no-parameter tool 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 opens with a specific verb and resource: 'Full catalog of tracked models — every model with a recorded price, including non-index entries.' It names the upstream source (Oracle API /v1/oracle/catalog), and later distinguishes itself from data_get_price, compute_estimate, and data_get_basket, so an agent can tell it apart from siblings without inspecting schemas.

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?

Usage context is explicit: this returns the full catalog, including non-index entries, and it passes the oracle document through unchanged. It also names alternatives with conditions: use data_get_price or compute_estimate for the same ladder normalized for flat models, and use data_get_basket for basket-only display. This is clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety and mutability. The description goes beyond these by disclosing that the data is raw, on-chain attested, and may lag the live catalogue ('they change only when an operator publishes a new revision'). This is valuable behavioral context not captured in annotations. Minor omission: no explicit note on absence of pagination or size limits, but the schema covers 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?

The prose portion is concise and front-loaded with the key purpose and caveatsavingly, but the description appends a massive auto-derived JSON schema (several hundred lines) directly in the description text. While there is no separate output schema, this bloats the description and makes it unwieldy. The prose sentences each earn their place, but the overall size violates conciseness.

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 no-parameter, read-only tool, the description is exceptionally complete. It explains the resource, the exact use case, the staleness caveat, the source, and includes the full response schema (since no output schema exists separately). An agent has everything needed to decide when to call it and how to interpret the result.

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

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

The tool has 0 parameters, and the rule gives a baseline of 4. The description adds no parameter-specific meaning because there are none to describe. The attached output schema inside the description doesn't affect parameter semantics. Given that schema description coverage is 100% (vacuously), the baseline holds.

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 resource ('Full Compute Price Index — raw oracle response') and lists exactly what it contains (canonical model id, provider, family, raw and marked-up prices, scuUsd, revisionVersion, last-updated). It explicitly distinguishes itself from data_get_price, data_get_basket, and data_get_breakdown by naming them and the conditions for their use. The verb is implicit in the tool name but the resource and scope are unambiguous.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: 'must not be quoted as what a model costs now — for that use data_get_price or data_get_basket' and 'For the per-family blended-cost breakdown, use data_get_breakdown.' It also states the provenance ('the figures the latest published revision attested on-chain') and 'Use this for the complete index data as attested.' This is a textbook example of routing the agent to the right alternative.

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

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

Beyond the readOnly/idempotent annotations, the description discloses non-obvious behavior: per-revision emission, daily/weekly step-function carry-forward, fields that may be null, and truncation semantics via the response schema. No behavior is hidden or contradicted.

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 summary sentence is front-loaded, followed by focused bucketing behavior, an alternative tool pointer, and the response schema. The embedded JSON is verbose but justified because there is no separate output schema.

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 read-only history tool with no required parameters, the description covers source, defaults, field semantics, bucketing behavior, the single-point alternative, and the full response structure. Combined with rich annotations, this is complete enough for correct invocation and result interpretation.

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 already documents all 4 parameters with 100% coverage, so the baseline is 3. The description adds only a compact default statement ('per-revision over the full range') and mostly repeats the granularity behavior already present in the schema.

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

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

The description opens with a specific verb and resource: 'SCU index time series — date-range history of Standard Compute Unit values'. It also names the source endpoint and differentiates from data_get_cpi for single-point fetches, making sibling selection straightforward.

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 clearly establishes when to use the tool: date-range history with optional bucketing, defaulting to the full range. It explicitly points to data_get_cpi for a single point at a specific timestamp, though it does not contrast against other similar history/price siblings.

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

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

Beyond the readOnly/idempotent annotations, the description discloses the source (Oracle API), that it returns a list of all versions plus an activeVersion pointer, and includes the full response schema. This richly documents what the agent can expect from the response.

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 core description is concise and front-loaded, but the embedded JSON response schema adds significant length. It is useful and well-organized, but the overall description is longer than necessary for a no-parameter read tool.

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?

This is a completely specified tool: no input parameters, a fully detailed response schema in the description, clear purpose and use case, and annotations covering safety. The description leaves no gaps for the 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?

The tool has zero parameters, so the baseline of 4 applies. The description does not need to add parameter semantics, and there are no parameters to document.

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

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

The description clearly identifies the tool as a 'Methodology changelog' that returns every registered methodology version with specific fields (formula summary, family rule, reference workload, spec reference) and the activeVersion. This is a specific verb+resource and clearly distinguishes it from sibling tools like data_get_scu or data_get_basket.

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

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

The description explicitly states when to use the tool: 'Use to interpret SCU values and to pin integrations to a methodology version.' This gives clear context but does not mention alternatives or exclusions, so it falls short of a full 5 per the rubric.

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 set readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description goes further by disclosing the advisory nature, TTL freshness window, and that a routable model can still fail at send time—explicitly advising error handling on the request. It also states the answer is the exchange's own, served verbatim, adding 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?

Though the description is moderately long, every sentence earns its place. It front-loads the core purpose, then layers source, structure, caveats, and alternatives in a logical progression. No redundancy or 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?

With no output schema, the description fully documents the response shape (computedAt, ttlSeconds, models with id and routable, auto alias) and semantics. It also covers the advisory limits and points to pricing alternatives. Nothing an agent needs to call it 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?

The tool has zero parameters and an empty schema, which is fully covered. The description explicitly confirms it 'takes no arguments,' adding a trivial but helpful confirmation. With 0 params, baseline is 4, and the description meets it.

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

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

The description opens with a precise statement: 'Which models can serve a request right now' and explicitly ties it to a decision point ('call it before choosing a model'). It names the resource (Compute Finance API /v1/models/availability) and clearly differentiates from siblings by noting it 'says nothing about price' and routing to data_get_catalog/basket and compute_estimate.

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 when-to-use guidance ('call it before choosing a model'), explains the benefit (rule out unservable models before a 503), and names specific alternatives for cost-related queries. This is a textbook example of routing the agent to the correct tool based on need.

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, openWorld, idempotent, and non-destructive, but the description goes well beyond that: it discloses the discriminated union ('manifest' vs 'catalog'), the modelKey/manifestKey distinction, the observedAt timing semantics, and specific error conditions (malformed/future dates, untracked models, pre-data dates). No contradiction with annotations 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?

The description is dense but well-organized: purpose, source, response union, naming, field semantics, errors, and schema. Every sentence contributes value, and the embedded response schema is justified because no separate output schema exists. It is longer than minimal but not wasteful.

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

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

For a tool with two parameters and a discriminated-union response, the description covers all necessary calling contract aspects: response shape via schema, union variants, naming aliases, error behavior, and field semantics. Nothing essential for correctly invoking this tool 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 coverage is 100%, with both parameters already described and exemplified. The description adds no new input semantics beyond what the schema provides; extra details like modelKey/manifestKey pertain to the response, not the parameters. A baseline of 3 is appropriate because the schema carries the full parameter burden.

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

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

The description opens with 'Per-model input/output USD price effective at a specific timestamp,' naming a specific resource and query type. It also clarifies canonical vs. bare model naming, making the tool's behavior unambiguous. The 'at' specificity distinguishes it from history/availability siblings even without naming them.

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 usage context is implied: use when a single point-in-time price is needed. However, the description never explicitly names alternatives or states when not to use this tool versus siblings like data_get_model_price_history or data_get_model_availability. Without such exclusions, an agent must infer the decision from names alone.

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, idempotentHint, openWorldHint, and destructiveHint=false, but the description adds significant behavioral context beyond them: the source endpoint, per-point field semantics and source enum, unavailableRevisions behavior, model naming resolution ('the bare name names the same model'), modelKey/manifestKey shipping conditions, and the exact error condition. This is far richer than the annotations alone and contains 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 front-loaded with the core purpose and each subsequent sentence adds factual value: source, point structure, naming, key semantics, and error conditions. The embedded OpenAPI response schema adds length, but it is justified because the tool has no output_schema field. It is dense rather than padded, though slightly long for a strictly minimal definition.

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 read-only history tool backed by rich annotations, this description is remarkably complete: it covers the source, response fields, granularity/limit semantics, naming resolution, unavailableRevisions behavior, error conditions, and the full response shape via the embedded schema. Nothing an agent needs to invoke it correctly is missing, and the absence of an output schema is compensated by the embedded response JSON.

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 baseline is 3. The description adds meaning beyond the schema by explaining that the bare model name resolves to the same model as the canonical vendor-prefixed id, and by clarifying modelKey/manifestKey semantics. It also references granularity and limit behavior tied to data_get_history, which supplements the schema's parameter descriptions without redundancy.

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

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

The description opens with a specific verb+resource: 'Per-model input/output USD price time series — date-range history for any oracle-tracked model.' This clearly states what the tool does and its scope. The emphasis on 'date-range history' differentiates it from point-in-time siblings like data_get_model_price_at and data_get_price, so it is not a tautology and stands apart from 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?

Usage is implied by the phrase 'date-range history for any oracle-tracked model' and cross-referenced semantics ('Same granularity ... and limit semantics as data_get_history'). However, there is no explicit statement of when to use this tool versus alternatives such as data_get_model_price_at or data_get_price, nor any exclusion criteria. An agent must infer the routing rather than being told 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?

The description goes far beyond the readOnlyHint/idempotentHint annotations, disclosing how billed_* is computed, how provenance marks work, what null max_input_tokens means, how context_tiers ladders are chosen, and what happens for unknown models ('Model not tracked by oracle'). It also explains that price_source names the serving endpoint only and does not change pricing basis, which prevents a likely misinterpretation.

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 long but every section carries needed information, and the most important facts about what price is returned are front-loaded. It is one dense paragraph rather than broken into headed sections, which slightly hurts scannability, but there is no fluff or repetition.

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

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

There is no output schema, so the description carries the full burden of explaining return values; it covers base prices, billed_* calculation, cache/reasoning components, provenance, context_tiers, max_input_tokens, price_source, error behavior, and id resolution. For a complex pricing tool, this is an unusually complete description.

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 baseline is 3, but the description adds substantial meaning beyond the schema: bare names resolve, ids are canonical vendor-prefixed, and vendor slugs do not always match provider keys (alibaba → qwen, xai → x-ai). This materially helps an agent pass the right model identifier.

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

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

The description opens with a specific verb+resource: 'Price for a single oracle-tracked model', naming exactly what is returned and distinguishing this from multi-model or historical siblings. It clearly states the pricing basis and the key output components, leaving no ambiguity about what the tool does.

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

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

The description makes clear this is for a single model's current oracle-tracked price, and distinguishes index members from catalog-only entries. It does not explicitly name sibling tools like data_get_model_price_history or data_get_basket, so exclusion guidance is implied rather than explicit, but the context is strong enough for an agent to select it correctly.

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 safety is covered. The description adds useful behavior beyond that: results are sorted most recent first, changes[].modelKey uses a bare manifest key requiring prefix stripping before joining, and the source is the Oracle API. This is valuable context beyond the annotations, though it does not address rate limits or error handling.

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 opening sentence is specific and useful, and the caveat about modelKey is important. However, the description includes a large auto-derived Oracle response schema JSON that adds significant bulk, making the whole definition somewhat verbose, even if it may be useful in the absence of a structured output schema.

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 supplies the full response shape, ordering, the modelKey join caveat, the source, and the optional limit parameter. With annotations covering read-only and idempotent behavior, this is nearly complete for a read-only list tool; missing only explicit sibling comparison and possible pagination details beyond a simple limit.

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

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

Since schema description coverage is 100% with the limit parameter already documented, the baseline is 3. The description reinforces limit semantics with 'Use the optional limit parameter to cap results' and adds sorting context, but it does not provide substantial new parameter meaning beyond the schema.

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

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

The description identifies the tool as returning 'Historical index changes' and enumerates the per-entry fields and typed changes[] list, so an agent can tell what data is returned. It stops short of an explicit verb like 'Retrieves,' but the name plus detailed field list make the purpose clear and distinguish it from the sibling data_get_* 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?

There is no guidance about when to choose this tool instead of alternatives like data_get_history or data_get_model_price_history. The description only explains the optional limit parameter and the sort order; it does not give selection context or exclusions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context: the discriminated-union breakdown shape, the computeIndex definition (inverse purchasing-power view anchored at 100), the critical caveat that breakdown.familyRepresentatives[].modelKey is a bare manifest key needing vendor-prefix stripping before joining, and the data source. 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?

Front-loaded with the core purpose, then structured detail about the breakdown union, computeIndex, methodologyVersion, the modelKey caveat, and sibling routing. Every sentence earns its place; the description is thorough without bloat, and the most important discriminator (alternatives) is near the end but clearly flagged.

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 read-only, idempotent, parameterless tool, the description covers everything an agent needs: the full response semantics (including the tricky modelKey nuance), how to interpret computeIndex, where to get the formula, and how to get just the breakdown or baseline. Even without a formal output schema, the description makes the call unambiguous.

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

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

The tool takes zero parameters (schema has no properties), so there is nothing to document beyond what the schema provides. The description focuses on output semantics instead, which is appropriate given the 0-parameter signature.

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 resource (Standard Compute Unit) and lists the key fields (value, breakdown, computeIndex, methodologyVersion). Explicitly names the sibling tools it is not (data_get_breakdown, data_get_baseline) and tells the agent exactly when to use them instead, making differentiation unambiguous.

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

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

Provides explicit routing: 'For the breakdown alone, use data_get_breakdown; for the baseline denominator, use data_get_baseline.' Also points to data_get_methodology for the formula. This covers when-to-use and when-not-to-use with named alternatives, 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 declare readOnly, idempotent, non-destructive. The description adds critical behavioral details: non-strict monotonicity with highest revisionVersion tie-breaking, computeIndex derivation formula, null for pre-genesis timestamps, and error conditions. This goes well beyond annotation coverage.

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 moderately long, but the core purpose and usage guidance are front-loaded. The inline Oracle schema is verbose yet provides valuable return-shape context. Each sentence contributes meaningful information, though the schema block could be considered slightly redundant given it's auto-derived.

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 single-parameter lookup tool, the description is exceptionally complete. It explains the output fields, edge cases (null, errors), the computeIndex formula, and routes to alternative tools. The inline output schema eliminates any ambiguity about 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?

The schema description for 'date' already covers format, future restriction, and null behavior. The description reinforces these points but does not introduce additional parameter semantics beyond the schema. With 100% schema coverage, 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 states a specific verb and resource ('SCU value active at a specific timestamp via step function') and explicitly differentiates itself from siblings like data_get_history and data_get_scu. It also notes 'no interpolation,' which clarifies the exact retrieval semantics.

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 direct guidance: 'Use data_get_history for a bucketed series; use data_get_scu_at for a single-point lookup.' It also explains edge cases (returns null for pre-genesis dates, errors on malformed/future dates), leaving no ambiguity about when this tool is appropriate.

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

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

Annotations indicate no strong side effects (readOnlyHint false, destructiveHint false, idempotentHint true). The description adds valuable behavioral context: data source (local transcripts + Oracle API), defaults (24h, top 10), and an explicit instruction to print the `text` field verbatim. This goes beyond annotations without contradicting them.

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

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

The description is concise and front-loaded with the core purpose, then provides source, output handling, and defaults. Every sentence carries distinct information, with no fluff or repetition.

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

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

For a tool with 3 optional parameters and no output schema, the description adequately covers purpose, data source, output handling, and defaults. Minor gaps exist: it does not explain what 'effective/nominal cost' means or whether any prerequisites are needed, but these are not critical for basic usage.

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% for all three parameters. The description additionally clarifies that `hours` defaults to 24 and `limit` defaults to 10, and that `cwd` limits to a working directory, enriching the schema's explicit definitions.

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 specifies the tool renders a pre-formatted table of recent Claude Code sessions with detailed metrics (Prompts, Inferences, Tool calls, tokens, costs). However, it does not explicitly differentiate from the sibling tool 'render_session_report', which could serve a similar purpose, so it lacks full sibling distinction.

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

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

The description implies usage for display (print text verbatim) and notes default look-back and limit, but it does not explicitly state when to use this tool over alternatives like 'render_session_report' or whether it complements 'analyze_session'. No exclusions or alternative recommendations are 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?

The description discloses the data source (local Claude Code transcript + Oracle API), output structure (rows per reply, canonical triplet), and truncation behavior (top-10/last-5 unless full=true). It also instructs to print the `text` field verbatim. Annotations already provide idempotency and destructive hints; the description adds useful behavioral context beyond that. There is no direct contradiction with readOnlyHint=false, though the description's implied read-only nature could be clearer.

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

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

The description is concise, with three sentences packing purpose, output details, and usage instruction. It is front-loaded with the tool's identity and avoids fluff. Minor issue: 'Bar chart, tool aggregates, mechanical facts' is a cryptic list that could be clearer.

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 rendering tool with no output schema, the description explains the output format (bar chart, rows per reply, header triplet), the `text` field, and the full parameter behavior. It also notes consistency with sibling reports. The only gap is the lack of clarity on cwd and session_id parameters, but overall the description gives sufficient context to invoke the tool and interpret results.

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 only 33%, with full described in the schema and the description also clarifying its effect (show every inference vs. truncation). However, cwd and session_id have no schema description and are not mentioned in the description, leaving their purpose unexplained. The description does not compensate for the low coverage on these two parameters.

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

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

The description clearly identifies the tool as a pre-formatted per-inference breakdown report for cf-session-consumption, with output specifics (bar chart, tool aggregates, one row per assistant reply). It does not start with a direct verb like 'Renders' but the name and content make the purpose clear. It distinguishes from siblings by noting the canonical triplet matches render_session_report and render_active_sessions, but doesn't fully explain how it differs from those.

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 context (per-inference breakdown, source data) and gives parameter-level guidance for full=true, but does not explicitly state when to choose this tool over its siblings or when not to use it. With 20 sibling tools, explicit guidance would be valuable.

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

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

Beyond annotations, it discloses 'logs to history' as a side effect and 'returns a text string' as output shape. The 'print verbatim — do not reformat' instruction is extra behavioral guidance without contradicting the idempotentHint.

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?

Six short, front-loaded sentences each carry useful information: purpose, source, behavior, output format, print instruction, parameter nuance. No filler or repetition.

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

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

Given only two optional string parameters and no output schema, the description adequately covers return type and core semantics. A minor gap is not explaining cwd or showing a sample report format, but overall enough 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 coverage is 0%, but the description adds meaning for session_id ('omit... for most recent session'). The cwd parameter remains unexplained, so parameter understanding is only partially improved.

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 identifies a 'pre-formatted session cost report' with explicit actions: reads transcript, prices it, logs, and returns text. Distinguishes from siblings via output format and report scope.

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

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

Description frames when it applies ('for cf-session-management skill', source, output use) and gives specific print verbatim and most-recent-session nuances. Does not explicitly name alternatives, but 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description goes further by disclosing dedup/last-wins semantics, the local data source, and the minimum-session requirement for insights. These are meaningful behavioral details 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 compact and front-loaded with the core purpose, then covers source, computed metrics, and an important threshold. Each sentence contributes necessary information without redundancy or 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 parameterless read-only tool, the description is complete: it states the data source, aggregation behavior, output content, and the prerequisite for insights. Annotations cover side-effect safety, and no output schema exists, so the described metrics and threshold provide the necessary 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?

The tool has zero parameters, so the baseline is 4. The description still adds value by enumerating the computed statistics and the condition for insights, which helps an agent understand what the result will contain even though no input configuration exists.

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 action ('Aggregate stats across logged sessions') and defines the resource scope ('logged sessions', 'local ~/.compute-finance/ storage'). It also lists concrete outputs (sample size, effective vs nominal cost, per-profile medians, insights), making the tool's purpose clear and distinguishable from siblings.

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 when to use this tool by mentioning 'logged sessions' and local storage, and it adds a threshold condition ('Insights require at least 5 sessions'). However, it does not explicitly contrast with sibling tools like render_session_report, compute_compare, or analyze_inferences, leaving some ambiguity about when this telemetry tool is preferred over alternatives.

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