corpusAI Cloud Pricing

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the paid nature (0.01 USDC per call), the 28-day bucket sampling, and the lack of history before 2026-09-05. This goes beyond the annotations and helps the agent understand cost and data availability.

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 information-dense, with the paid cost warning front-loaded, followed by the data format and collection history. Every sentence adds value and there is no fluff.

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

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

The description covers the data source, format, sampling, history start, and cost. It doesn't describe the return structure (no output schema), but for a time-series data tool, the description gives enough context for an agent to call it correctly. The only minor gap is not explicitly stating the response format, but the description is otherwise complete.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds context about the eviction-rate bucket values and the sampling period, but it doesn't add much beyond the schema for parameter semantics. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns Azure spot eviction-rate history, with specific detail on the 28-day buckets, sampling frequency, and SKU/region scope. It distinguishes itself from sibling tools by naming the exact data source (Azure spot eviction rates) and the metric format.

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

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

The description explains the data collection cadence and the date range, and the schema provides defaults for from/to. It doesn't explicitly name alternative tools for other cloud providers or spot pricing data, but the context is clear enough for an agent to know when to use this tool for Azure eviction history.

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

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

Annotations already cover readOnly, idempotent, and non-destructive behavior. The description adds a paid cost (0.10 USDC per call) and that the result is sorted tightest first, which are useful. However, it omits details like pagination or whether many rows are returned, which could matter for an agent. Since annotations handle safety, a 3 is appropriate.

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

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

The description is one concise sentence, front-loading the paid cost and then stating the core function. It is efficient and easy to scan. It could be slightly more structured (e.g., noting the sort order more explicitly), but overall it is well-sized 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 simple read-only tool with one optional parameter, the description is adequate but not complete. It states the output (scores for all models, sorted) but does not describe return structure, limits, or if there are any special cases (e.g., missing data for a day). Without an output schema, an agent might need to infer the exact fields, so a 3 is fair.

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 only parameter 'day' is fully described in the schema with format and default. The tool description does not add extra meaning about the parameter—it only implies a single day via 'for one day'. With 100% schema coverage, the baseline of 3 holds; the description contributes nothing 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 states a clear function: returns capacity stress scores for all GPU models for one day, sorted tightest first. It is specific about the resource (GPU model capacity stress) and the time scope. However, it does not explicitly differentiate itself from sibling tools like capacity_stress or capacity_headline beyond the 'board' phrasing, so it earns a 4 rather than 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?

There is no guidance on when to use this tool versus alternatives. The description only explains what it does; it does not mention scenarios like comparing across days (use capacity_history) or getting a headline number (capacity_headline). Without such exclusions or context, an agent may not know when this is the best choice.

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?

Adds meaningful behavioral details beyond annotations: the result is rounded 0–100, requires at least two signals per GPU, orders by 'tightest first', is cached for ten minutes, and returns score only. No contradiction with readOnly/idempotent hints.

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

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

Three short sentences, all carrying distinct information: pricing tier, result scope, rounding/ranking, caching, and pointer to paid endpoints. No fluff, and the core deliverable is front-loaded.

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

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

Without an output schema, the description fully covers what is returned: per-GPU score, rounded 0–100, latest day, with minimum signal count and ordering. It also tells agents where to find deeper details, making the endpoint self-sufficient.

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

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

The input schema is empty and schema description coverage is 100%, so the baseline of 4 applies. The description adds nothing parameter-related because there are no parameters, which 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?

States the resource precisely: capacity stress score per GPU model for the latest day, score only. It distinguishes itself by naming the paid endpoints /capacity/stress and /capacity/board that carry the components and inputs.

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?

Clearly signals when to use it: for a free, quick headline score, with 'score only' and 'cached ten minutes' as practical constraints. It names alternatives implicitly by pointing to paid endpoints for detailed components and inputs, though it doesn't state an explicit 'when not to use' condition.

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 cover readOnly (safe read) and idempotent. The description adds the cost and the daily granularity, which is useful. However, it does not explain what 'stress scores' represent, how many data points are returned, or the default time range when 'from'/'to' are omitted. With annotations present, the bar is lower, and this is adequate but not rich.

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

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

The description is a single sentence that front-loads the cost and states the core functionality. It is concise and free of filler, though it omits usage guidance. Its brevity is a plus, but the lack of context holds it back from a 5.

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

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

For a simple read-only tool with 3 parameters and no output schema, the description provides enough to call it correctly. However, it does not clarify the semantics of 'stress scores' or the behavior when 'from'/'to' are absent, and it does not differentiate from sibling capacity tools. This is a moderate gap.

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

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

Schema description coverage is 100%, so all parameters (gpu, from, to) are already documented with formats and an example for gpu. The description adds no parameter-specific meaning beyond the schema, 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 clearly states the resource (GPU model) and the metric (daily capacity stress scores). The word 'history' implies a time series, distinguishing it from siblings like 'capacity_stress' without naming them explicitly. It is specific but not perfectly differentiated.

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

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

No guidance is given on when to use this tool versus sibling tools such as capacity_stress or capacity_headline. The only extra information is a cost warning (0.05 USDC per call), which is not usage guidance. The agent must infer the historical scope from the name.

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 establish read-only, idempotent, non-destructive behavior, so the description only needs to add behavioral context. It adds real value: the per-call cost, the mean-over-available-components behavior, and the exact normalization mappings for spot_ratio. 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 effective, front-loading the cost and score scale before explaining the formula. The formula details are long but earn their place because they define the output semantics. The phrasing is a bit run-on, but there is 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 read-only, two-parameter tool with strong annotations and no output schema, the description covers the essential invocation context: required GPU, optional day, cost, score range, and component definitions. It does not spell out the exact response shape or behavior when no components are available, but that is a minor gap given the annotations and schema coverage.

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 applies; gpu and day are already described with format and default information. The description reinforces that gpu selects one model and day selects one day, but it does not add materially new parameter-level semantics beyond the schema.

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

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

The description clearly identifies the resource (capacity stress score) and scopes it to one GPU model on one day, with an explicit 0–100 range. It lacks an action verb like 'returns' or 'computes' and does not contrast itself with sibling capacity tools, but the scope and component breakdown make the purpose unambiguous.

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

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

There is no guidance on when to use this tool instead of alternatives such as capacity_headline, capacity_board, or capacity_history. The description implies a single-day, single-GPU use case, but it never states the selection criteria or warns against using it for broader capacity summaries.

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 carry the safety profile (readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds some behavioral context beyond annotations: 'Free,' the one-row-per-(provider, region) structure, and the semantics of the `sources` legend. It does not disclose pagination, size limits, or response shape, but those are minor given the strong 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 compact and information-dense, with each clause contributing (contents, row structure, legend, reuse guidance). The opening fragment 'Free. Providers, regions, coverage window and event counts.' is somewhat choppy and slightly redundant with the detail that follows, but there is no filler or repetition worth cutting.

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 with no output schema, the description explains return semantics well: row granularity, the two coverage types, the `sources` legend, and how to consume the values. Minor gaps remain—what 'Free' means exactly and the internal shape of the `sources` legend—but 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 schema coverage is trivially 100%, so the baseline is 4. The description correctly does not attempt to document parameters. The 'Use the region values here verbatim in every other call' note indirectly explains how output values feed other tools' parameters, which adds value beyond the schema.

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

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

The description clearly enumerates the resource contents: providers, regions, coverage windows, event counts, and a `sources` legend. Although it lacks a specific verb like 'list' or 'retrieve' and opens with a fragment ('Free. Providers, regions...'), an agent can tell this is the metadata/coverage catalog. It does not explicitly name a sibling it differs from, but the content enumeration makes its role distinct among the sibling tools.

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

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

The closing instruction, 'Use the `region` values here verbatim in every other call,' gives explicit, actionable guidance on when to consult this tool: it is the canonical source of region values for all other calls, and its `sources` legend explains values used by /spot/daily and /spot/monthly. It stops short of naming alternatives or exclusions, but the usage 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, idempotentHint, and destructiveHint=false, and the description adds meaningful behavioral context: the 0.05 USDC per-call cost, how aws-spot/gcp-spot rows are computed from spot price events, and data coverage start dates. This goes beyond what annotations alone provide, though it does not describe output format or pagination.

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 every sentence earns its place: cost, core output, per-day metrics, special spot-row methodology, and history availability. It front-loads the most important facts and avoids 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 still explains the return shape—snapshot day, provider, market, quote count, and low/median/mean/high prices—and covers cost and data caveats. It lacks only minor operational details like default ordering or response size, but an agent has enough to call and interpret 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?

Schema description coverage is 100%, so the schema already documents gpu, from, and to. The description clarifies that the result is a per-model index, which reinforces the role of the gpu parameter, but it does not add substantial parameter-level meaning beyond the schema.

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

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

The description clearly defines the tool's output: a daily USD per GPU-hour index per provider and market for one GPU model, including quote counts and min/median/mean/max prices. It also distinguishes this from raw quote or event tools by describing the hyperscaler spot leg computation, so an agent can tell it apart from siblings like gpu_quotes or spot_daily.

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

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

The description implies the use case—historical daily indexed prices per provider and market—but it never explicitly states when to prefer this tool over siblings such as gpu_quotes, gpu_snapshot, or index_history. No when-not-to-use guidance or alternative routing is given.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds meaningful context beyond that: the tool returns normalized model names, quote aggregation metrics, observation time windows, and hyperscaler spot mappings. 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 compact and dense, with the core purpose front-loaded and the field list following in one sentence. The standalone 'Free.' is slightly abrupt but not wasteful; every sentence contributes useful 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 carries the burden of describing return contents, and it does so thoroughly: model names, provider counts, quote counts, snapshot range, lowest price, and spot mappings. It does not mention ordering or pagination, but with zero parameters that is a minor gap for a read-only reference 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?

The input schema has zero parameters, so the baseline is 4. The description's mention of normalized model names and 'use verbatim as `gpu`' adds useful downstream context even though there is no schema parameter 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 identifies the resource (GPU models) and the exact contents: rental quotes, provider counts, snapshot dates, lowest USD per GPU-hour, and hyperscaler spot mappings. It lacks an explicit verb like 'list' or 'get', but the scope is clear and distinguishable from sibling quote/history 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 explicit statement about when to use this tool versus siblings like gpu_quotes or gpu_snapshot. The note 'use verbatim as `gpu`' is a downstream usage hint rather than a when-to-use guideline, and no alternatives or exclusions are mentioned.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value beyond those: the per-call cost, daily snapshot cadence, exact data sources, and the meaning of each market tier. This is useful behavioral context with 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 dense but every sentence earns its place: paid caveat, scope, row contents, market definitions, sources, and cadence. It is slightly monolithic as a single paragraph rather than front-loaded bullets, but the most critical decision factor (cost) leads and the rest is necessary detail.

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 shape and it does: one row per quote with fields (provider, market, GPUs, USD per GPU-hour, quoted unit price, region, extra). Sources and snapshot timing are covered. Minor gaps remain (row count from Vast's 'cheapest 64 offers', pagination), but an agent can invoke this correctly with what's given.

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 real meaning beyond the schema: it defines market semantics (spot = interruptible, bid = marketplace minimum bid, secure/community = RunPod tiers), the unit (USD per GPU-hour vs. quoted unit price), and what provider-specific `extra` contains. This substantially helps the agent pick correct parameter values.

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

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

The description states a specific verb+resource: it returns the latest rental quotes for one GPU model across multiple providers and markets. It clearly differentiates from siblings like spot_latest or ondemand by enumerating the covered markets, sources, and daily-snapshot structure, though it never explicitly names an alternative tool.

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 implied: the tool is paid (0.01 USDC per call), scoped to one GPU model, and returns each provider's latest daily snapshot. However, there is no when-to-use vs. when-not-to-use guidance or mention of sibling alternatives (e.g., spot_latest, ondemand, gpu_snapshot), leaving the agent to infer selection criteria.

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 cover readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the cost detail (0.10 USDC per call), which is a valuable operational note beyond the annotations, but it does not disclose return format, pagination, or other behaviors. With annotations handling safety, this is adequate but not rich.

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?

One sentence, front-loaded with the cost warning, followed by a compact but precise description of the returned data. No filler 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?

With no output schema, the description carries the full burden of explaining what is returned. It covers the range of data (GPU models × providers × markets) and the metrics (lowest/median prices, hyperscaler spots). Minor ambiguity around 'hyperscaler spot per region' could be clearer, but it is sufficient for a snapshot endpoint.

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 schema (empty object) covers everything. The description correctly focuses on the output content rather than parameters. Since there are no parameters, the baseline is 4, and the description adds no parameter-specific semantics because none are needed.

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

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

The description states exactly what the tool returns: for every GPU model × provider × market, the lowest and median USD per GPU-hour in the latest snapshot, plus hyperscaler spot per region. It uses a specific verb-resource pattern and differentiates from sibling snapshot tools (ondemand_snapshot, reserved_snapshot, spot_snapshot) by being the general GPU market snapshot.

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 the tool (when you need a whole-market GPU price snapshot), but it does not explicitly contrast with siblings or state when not to use it. No alternatives are mentioned, leaving an agent to infer the right choice among the many snapshot endpoints.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable detail: the 'ready' flag behavior after restart and the 503 response for paid endpoints until ready. It also confirms the cost (free). This goes beyond annotations and helps agents understand operational implications.

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

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

The description is two concise sentences, front-loaded with the key message 'Free. Liveness and store readiness.' Every sentence adds essential information: the HTTP status meaning, the ready flag, and the effect on paid endpoints. No word is wasted.

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 health check, the description is largely complete. It explains the return status, the ready field, and the impact on paid endpoints. However, it does not detail the exact response body structure (e.g., fields beyond 'ready'), but given the simplicity and lack of an output schema, this is acceptable. The information provided is sufficient for an agent to use 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?

With zero parameters, the baseline is 4. There is nothing for the description to clarify about parameters since the schema is empty. The description correctly focuses on behavior instead, and no additional parameter semantics are needed.

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

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

The description clearly states the tool's purpose: 'Liveness and store readiness.' It explains that it returns 200 when the server is up, distinguishing it from the many data-providing sibling tools. The verb is implied (check), but the resource and behavior 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 provides useful context: it is free and tells agents that paid endpoints answer 503 until the store is ready. This implies using this health check before calling paid endpoints, though it does not explicitly say 'use this to check readiness before other tools.' It gives sufficient guidance within the context of sibling 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 cover read-only, idempotent, non-destructive behavior, so the description's addition of per-call cost (0.10 USDC) and the batching promise ('one call') adds valuable behavioral context. It does not explain response format or rate limits, but these are less critical given the annotations.

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

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

Two short sentences, each carrying essential information: the cost and the scope/batching behavior. No filler or repetition of schema/annotations.

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 one-optional-parameter read-only endpoint, the description plus annotations and schema cover what the agent needs to select and call it: cost, day input, default, and result scope. It stops short of describing the output shape or alternatives, but this is a minor gap for such a simple 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?

The schema already documents the single optional `day` parameter with format and default, so the description need not add much. It adds only the notion of 'one day' without repeating or enhancing the parameter semantics. Baseline 3 is appropriate for 100% schema coverage.

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

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

The description states that the tool returns every ticker's fixing for a single day in one call, which is a specific resource and scope. However, it never uses an explicit retrieval verb and relies on the title/siblings to clarify that these are index fixings, so it doesn't fully distinguish itself from index_fixing or index_history.

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 phrase 'every ticker's fixing for one day in one call' implies this is the endpoint to use for a full cross-section of fixings on a single day. It gives no explicit when-to-use/when-not-to-use guidance or named alternatives, leaving the agent to infer routing from sibling names.

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 all safety hints (readOnly, idempotent, non-destructive), so the bar is lower. The description adds crucial behavioral details: the cost (0.01 USDC per call), the segment-dependent default day, and the fact that SPOT composites carry per-region values and spread_vs_neo. It also points to /methodology for eligibility, making the tool's behavior and limitations transparent.

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

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

The description is three sentences, front-loaded with the cost and core return value, then explains segment variations and points to methodology. Every sentence earns its place with no redundancy or 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 simple 2-parameter tool with no output schema, the description covers the essential behavior: return fields, default day semantics, segment differences, and reference to methodology. The only minor gap is that it doesn't explicitly state the exact JSON structure of the response, but since no output schema exists and the fields are named, this is acceptable. The completeness is strong for the complexity level.

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 already documents both parameters with descriptions (100% coverage), giving a baseline of 3. The description adds meaningful nuance: it clarifies that the 'day' default is not universally 'latest available' but depends on whether the ticker is a quote segment or SPOT, and it explains the output fields (median, low, high, count) that are implied by the parameters. This goes beyond the schema's static default text.

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

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

The description clearly states this tool returns one day's fixing data (median USD per GPU-hour, low, high, count) for a given ticker. It distinguishes itself from siblings by explicitly describing the segment-specific behavior (MKT/NEO/INT/HYP vs SPOT) and the meaning of composite values, making it unmistakable what this 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 provides strong context on when to use the tool by explaining the default day logic (latest snapshot for quote segments, yesterday for SPOT) and referencing the full methodology. It does not explicitly mention alternates like index_history or spot_daily, but the segment and composite details give enough clue that this is the tool for daily fixings, making the usage intent clear even without direct sibling exclusion.

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

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

The description adds substantial behavioral context beyond the annotations: the 0.05 USDC per-call cost, the start dates for quote and spot series, and the fact that each row carries its data source. These details are not present in the annotations and meaningfully inform the agent about side effects and data provenance.

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: it opens with the paid cost, then the core purpose, then the relevant data availability notes. Every sentence carries useful information without redundancy.

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

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

For a relatively simple read-only history tool, the description covers the main invocation concerns: what it returns conceptually, the date-range scope, pricing, and data source availability. It does not detail output columns or pagination, but with no output schema and low parameter complexity, the description is sufficiently complete for an agent to select and call the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the date-range concept and provides availability context, but it does not add new semantics for the ticker, from, or to parameters beyond what the schema already states.

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

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

The description clearly states the resource and action: 'Daily fixings for a ticker over a date range.' It is not a tautology and gives enough specificity to understand the tool's purpose, but it does not explicitly name sibling tools to differentiate itself, 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?

The description gives clear context: this tool provides daily fixings over a date range, with pricing and data availability details. It implies when to use it, but it does not explicitly state exclusions or name alternatives such as index_fixing or spot_daily, so it lacks full when-not 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 mark readOnly, idempotent, open-world, and non-destructive, so the bar is lower. The description adds useful behavioral content by stating the result is free and by disclosing exactly what the payload includes: ticker format, segment membership lists, and methodology version. There is 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?

Three short sentences with no filler; the cost note is front-loaded, followed by scope, concrete examples, and included artifacts. Every sentence earns its place.

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

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

For a zero-parameter read-only reference endpoint, the description covers the essential output contents and naming scheme. Since no output schema exists, the description's enumeration (tickers, segment, definition, membership lists, methodology version) serves as the primary documentation and is sufficient for an agent to call and interpret the tool.

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

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

The schema has zero parameters, so the baseline is 4. The description adds useful meaning for interpreting returned data by defining ticker syntax (CX.<MODEL>.<SEGMENT> and CX.<MODEL>.SPOT.<REGION>), even though no parameters exist 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 identifies the resource ('every index ticker') and enumerates the returned content: segment, definition, ticker format, membership lists, and methodology version. 'Every' plus the naming convention makes its scope clear, distinguishing it from the index_history and index_board siblings. The implicit verb 'returns/lists' is obvious from context.

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

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

It implies a reference use case: use this when you need the full catalog of index ticker codes, their segments/definitions, or methodology version. It does not explicitly name sibling alternatives or state when not to use this tool, such as for historical index data. The 'Free' note hints at cost considerations but not invocation context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, lowering the bar. The description adds valuable behavioral context: the call is free, the prefix narrows results, and zero/null appears for types that only exist in legacy history. It does not cover pagination or rate limits, but for a read-only list tool this is adequate.

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

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

Three short sentences with no filler. The 'Free' cost note, the output-field enumeration, and the prefix example each add distinct information, and the most important scope appears 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?

Even without an output schema, the description enumerates the returned per-type coverage fields and legacy history ranges, and the schema documents the required provider and region parameters. It does not mention pagination or error cases, but the tool is low-complexity and the annotations cover the safety profile, so the definition is sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by giving concrete prefix examples (`c5.`, `n2-`) and clarifying that the prefix narrows the list, which goes beyond the schema's simple 'Case-sensitive prefix filter'.

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 resource ('Instance types available in a region') and adds distinguishing output details such as per-type coverage fields and legacy history ranges. However, it lacks an explicit verb like 'list' and does not name sibling tools, so it does not fully differentiate from tools like catalog or term_instance.

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

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

No explicit guidance is provided on when to use this tool versus siblings such as catalog or term_instance, and no prerequisites are stated. The intended scope is inferable, but the description never says 'use this when...' or names alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds valuable behavioral context: the 0.01 USDC per-call cost, the change-point series semantics, refresh cadence per provider, and the explicit 'not refreshed' caveat for GCP. These go beyond the structured annotations and materially inform call decisions.

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

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

The description is dense but efficient. It front-loads the cost and core purpose, then provides per-provider specifics in compact sentences. Every sentence adds value, though the provider details could arguably be condensed without much loss.

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 adequately explains the return format (change-point series, `current` field), data sources, refresh frequency, and coverage periods. It covers the essential information an agent needs to invoke the tool correctly, though it omits potential edge cases like empty results or error conditions.

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%; provider, region, and instance each have clear descriptions with examples. The tool description does not add extra parameter-level meaning beyond what the schema already states, only reinforcing that it handles 'one instance type'. This matches the baseline for high schema coverage.

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

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

The description clearly states a specific verb-resource pair: 'On-demand list-price history of one instance type' and details the output as a change-point series with one row per day the price changed. This distinguishes it from siblings like spot_* and ondemand_snapshot, which serve different data modalities.

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

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

No explicit guidance on when to use this tool versus alternatives such as ondemand_snapshot or reserved. The word 'history' implies it is for historical data, but there is no direct statement about preferring this for change-point analysis or for comparing with spot history. No exclusions or conditions are given.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: it is a paid call costing 0.10 USDC and provides current pricing. This is valuable for an agent deciding whether to invoke the tool.

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

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

The description is two short sentences with no filler. The paid cost is front-loaded and the core purpose is stated immediately. Every word contributes to understanding the tool's function and cost.

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

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

The tool is simple with only two well-documented parameters, and the description states what it returns (current on-demand list prices for every instance type in a region) and its cost. There is no output schema, so a bit more detail on the return shape could help, but for a snapshot/pricing tool this is reasonably complete.

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

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

Schema description coverage is 100%, with both 'provider' and 'region' fully documented including examples and enum values. The description adds little beyond the schema, only clarifying that the result covers every instance type in a region. Baseline 3 is appropriate because the schema carries the parameter documentation 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 clearly identifies the resource: current on-demand list prices for every instance type in a region. It lacks an explicit verb like 'get' or 'list', but 'Current on-demand list price' conveys the retrieval intent. It is distinct enough from siblings like reserved_snapshot and spot_snapshot by specifying 'on-demand' and 'region'.

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 context that this is a region-scoped, paid on-demand pricing lookup, but it does not state when to prefer it over alternatives such as 'ondemand' or 'spot_snapshot'. No exclusions or comparison to sibling tools are provided, so an agent must infer usage from the name and brief description.

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 establish read-only, idempotent, non-destructive behavior. The description adds substantial behavioral context beyond that: the 0.01 USDC per-call cost, the effective hourly USD calculation with amortized upfront, the change-point series structure, provider-specific data sources, refresh cadence, and history depth.

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 every sentence earns its place: the paid nature and core scope are front-loaded, followed by AWS/Azure/GCP-specific facts. There is no fluff or repetition of schema 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?

For a multi-provider, no-output-schema tool, the description is remarkably complete: it specifies cost, data sources, update frequency, history start dates, pricing computation, and scoping rules. The only mild ambiguity is the exact shape of a 'change-point series,' but that is not needed to select or invoke 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?

Schema coverage is 100%, so the baseline is 3. The description adds meaningful value by mapping ri_type values to providers, clarifying that instance names must match /instances exactly, and noting provider-specific region slug conventions. It does not fully explain every parameter, but the schema already carries precise descriptions.

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

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

The description defines the exact resource—reserved/reservation price history—and scopes it to a single instance type across AWS, Azure, and GCP with specific term types. It is unambiguous and clearly distinct from sibling tools like ondemand or spot_* by focusing on commitment-based pricing.

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 intended use is implied strongly by the name and content: use this when reserved or commitment-based price history is needed. However, the description never explicitly states when to prefer this tool over alternatives like reserved_snapshot or ondemand, and it gives no exclusions or conditional 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 establish read-only, idempotent, non-destructive behavior; the description adds the paid call cost (0.10 USDC) and the 'current snapshot' nature. It does not mention output format, pagination, or data freshness, but with low risk annotations this is acceptable.

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 short sentences with the cost warning front-loaded and no filler. Every clause adds information about cost or data 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?

For a simple two-parameter read-only tool the description covers the returned data, but the 'AWS or Azure' phrasing conflicts with the schema's gcp option and leaves the actual provider scope ambiguous. It also uses ri_type without defining it, which matters more because there is 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 region and provider fully documented including an enum and default. The description adds little beyond confirming the result is per-region and mentions ri_type, which is output vocabulary rather than parameter guidance.

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

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

The description names the exact data returned: current reserved effective hourly price for every instance type and ri_type in a region, which distinguishes it from spot/on-demand snapshots. It loses a point because it has no explicit verb like 'get/list' and its parenthetical says 'AWS or Azure' even though the schema provider enum includes gcp.

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

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

No statement about when to prefer this tool over sibling tools such as reserved, ondemand_snapshot, or spot_snapshot. The only guidance is implied by the word 'reserved', which requires the agent to infer the intended use case.

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 annotations by disclosing the per-call cost, legacy vs direct data sources, source field values, time-weighted and zone-collapsed methodology, the relationship of avg to the public dashboard, and null OHLC behavior. This is rich, non-obvious behavioral context with no contradiction against 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 dense but well-organized: it front-loads payment, purpose, and row granularity, then details the legacy/direct sources and null behavior. No filler is present, though the single-paragraph structure makes the provenance details slightly heavy.

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 adequately explains what rows will look like: one per UTC day, source distinctions, OHLC/avg fields, and null semantics. It could name the explicit output columns, but for a complex multi-era tool the coverage is strong.

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 five parameters already explained and examples provided. The description adds little parameter-specific meaning beyond reinforcing that from/to span the full daily history; the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly identifies the resource as 'full daily history for one instance type, all eras stitched' with one row per UTC day. It conveys daily granularity and distinguishes itself from hourly/monthly/snapshot siblings by scope, though it never names an alternative directly.

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 implied: daily history, one instance type, paid, and same method as /spot/hourly. However, the description does not explicitly state when to choose this tool over spot_hourly, spot_monthly, spot_latest, or spot_snapshot, nor does it provide exclusion criteria.

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 non-destructive behavior, and the description adds substantial context: cost per call, event granularity, exact returned fields, chronological sorting, deduplication of repeated prices, and pagination via truncated/next_from. It goes well beyond what the annotations or schema alone 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?

Four dense sentences, each contributing needed information: cost, core resource, output contents and ordering, dedup behavior, and pagination. There is no filler, and the most important facts are front-loaded.

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

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

For a tool with 9 parameters and no output schema, the description gives the agent enough to call it correctly: what rows contain, how they are ordered, how repeated prices are handled, and how to continue pagination. The absence of an output schema is adequately compensated by the description of the result contract.

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. The description adds useful semantic detail beyond the schema, especially the meaning of include_repeats deduplication and the pagination contract involving limit, truncated, from, and next_from. It does not exhaustively restate every parameter, but it does not need to.

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 resource: raw spot price-change events for one instance type, with exact timestamp, availability zone and product. The phrase "for one instance type" and "raw" help separate it from aggregate or all-instance siblings, though it never states an explicit verb like 'list' or 'get' and does not name a specific sibling tool.

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 conveys that this tool is for raw per-event spot price history and warns about the per-call cost, which implies the intended use case. However, it does not explicitly state when to prefer alternatives like spot_latest, spot_snapshot, or spot_daily, nor does it give 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?

Beyond the read-only and idempotent annotations, the description discloses meaningful behavior: the call costs 0.01 USDC, bars are time-weighted by how long a price was in force, per-zone series are collapsed with median/max/min logic, and the window is capped at 366 days. These are non-obvious facts the annotations and schema 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?

Three sentences deliver cost, granularity, scope, aggregation methodology, and window limits with no filler. Decision-relevant facts are front-loaded before the technical collapse logic.

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 query tool with fully documented parameters and no output schema, the description explains both the call constraints and the returned OHLC aggregation semantics. It omits explicit response-shape or pagination details, but those are minor given the tool's simplicity and the rich annotations.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by constraining from/to to a maximum 366-day window and emphasizing that exactly one instance type is queried, which clarifies the scope of the instance parameter 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 states the deliverable clearly: hourly time-weighted OHLC bars for one instance type. The granularity and single-instance scope distinguish it from siblings like spot_daily, spot_monthly, and spot_latest without needing to open their 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 implies usage via the word 'hourly' and the 'one instance type' constraint, and it adds a 366-day window cap. However, it never explicitly routes the agent to alternatives such as spot_daily or spot_monthly or states when not to use this tool, so the guidance remains inferential.

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, so the safety profile is covered. The description adds valuable behavioral context: the call is paid (0.01 USDC per call), the price is only meaningful while the provider still offers the type, and AWS series older than ~10 days are likely retired while GCP/Azure reprice rarely. This goes beyond the annotations and helps the agent interpret results correctly. A small gap: it doesn't describe the exact response shape, but with no output schema and read-only annotations, the added context is strong.

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: it starts with the paid nature and the core purpose, then adds timestamp interpretation context, and ends with the sibling alternative. Every sentence earns its place, and the structure 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?

For a read-only, idempotent, single-instance lookup tool with 100% schema coverage, the description is nearly complete. It covers cost, data meaning, timestamp interpretation, and the alternative for broader queries. The only missing piece is the exact response format, but since there is no output schema and the tool is simple, this is a minor gap. The description is complete enough for an agent to select and invoke 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?

Schema description coverage is 100%, so the schema already documents all three parameters (provider, region, instance) with examples and enum values. The description adds the notion that the price is per zone and product, which implies the instance parameter is a type name, but it doesn't add much beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a specific verb ('spot_latest' returns the most recent price event per zone and product for one instance type), names the resource (spot price events), and distinguishes itself from the sibling /spot/snapshot by noting that snapshot returns every type in a region at once. This is a clear, specific purpose that an agent can act on.

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

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

The description explicitly says when to use this tool (for the current price in force per zone/product for one instance type) and when not to use it (for every type in a region at once, use /spot/snapshot). It also provides context about AWS vs GCP/Azure timestamp interpretation, which helps an agent decide if the data is meaningful. This is explicit usage guidance with an alternative named.

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

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

Annotations already declare readOnlyHint true and destructiveHint false, but the description adds substantial behavioral context: the paid cost per call (0.05 USDC), the provenance of archive data (third-party, partly unverified), and the guarantee that archive is returned separately so it never blends with curated data. These details go well beyond annotations and inform the agent about cost and data trustworthiness.

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 and information-rich; every sentence adds value—cost, scope, series definitions, and provenance warnings. It is long but not wasteful, front-loaded with the paid note and core purpose. It earns a 4 for efficiency given the complexity it must convey.

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 six parameters and complex output (curated vs archive), the description fully explains the output structure: the fields of 'months' (avg, open/close, high/low, days, source) and the archive's content and provenance. It also notes the historical depth. No output schema is provided, so the description carries the full burden, and it covers cost, data ranges, and separation—nothing essential 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%, so the description does not need to explain parameters. The description does not add any additional parameter semantics; it focuses on output structure. Per the baseline rule, this scores 3.

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

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

The description states a specific verb (get monthly history) and resource (one instance type), and clarifies scope (calendar months, back to 2014 for legacy AWS). It also distinguishes the curated series from the archive, and the mention of 'rolled up from the daily series' differentiates it from daily/hourly siblings. This is clear and 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 explains the structure and separation of 'months' and 'archive', and notes the archive is returned separately to avoid silent blending. However, it does not explicitly state when to prefer this tool over spot_daily or spot_hourly, though the name and context imply the right use case. It provides clear context but no explicit exclusions 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?

Beyond the readOnly and idempotent annotations, the description discloses a $0.10 USDC charge per call, an approximate row count for AWS regions, and per-row timestamp/age fields. It also specifies that semantics match /spot/latest, giving the agent useful operational context before invoking.

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 and front-loaded with the cost and scope. The final sentence about being priced higher partially repeats the opening payment note, but it earns its place by explaining the trade-off versus a narrower snapshot.

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?

Even with no output schema, the description covers the return shape: rows, timestamps, age, and approximate count. It gives enough context for an agent to know what it will receive and why the call costs more, though the term 'series' is not fully defined.

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%: both provider and region have descriptions and provider has an enum. The description adds no extra parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description clearly identifies a whole-region bulk snapshot of current spot prices across all instance types, zones, and products, and it distinguishes itself by scale and cost. The verb is implicit rather than explicit, but the resource and scope are concrete enough to separate it from siblings like spot_latest.

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

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

The description states the primary use case: get the entire current price surface of a region in one call. Referencing /spot/latest and the higher price implies the alternative for narrower queries, though it stops short of explicitly saying 'use spot_latest for a single series or when cost matters more.'

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 this safe and read-only; the description adds valuable behavioral context beyond that: a hard cost of 1.00 USDC per call, roughly 80,000 rows for AWS, and that `regions` contains per-region as-of timestamps. This helps an agent anticipate cost and response size.

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?

Each sentence earns its place: cost is front-loaded, scope is explicit, and the relationship to /spot/snapshot plus output characteristics are stated in two compact sentences. No filler 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?

For a one-parameter read-only tool with no output schema, the description gives enough context to invoke it correctly: scope, relationship to /spot/snapshot, rough result size, and `regions` semantics. It stops short of fully describing response fields, but the 'same rows as /spot/snapshot' reference covers that adequately.

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

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

The schema already documents the sole `provider` parameter with a full enum and 100% coverage. The description mentions 'of a provider' and uses AWS as an example, but it does not add materially new parameter-level meaning beyond the schema.

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

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

The description clearly states the resource (spot price snapshot), scope (every type, zone, and region of a provider), and differentiates from the related /spot/snapshot endpoint by noting it covers all regions in one call. The row-count detail reinforces the all-region 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?

The phrase 'Same rows as /spot/snapshot, for all regions' provides context for when this tool is appropriate versus a more targeted snapshot. It does not explicitly say 'use spot_snapshot for single-region queries,' but the contrast is clear enough.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds value beyond annotations by disclosing the output payload shape (per-source last success, staleness in days, source URL) and the zero-cost behavior, which helps an agent anticipate what the call returns.

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, every one earns its place: the opening states scope and cost, the second details the returned fields, and the third gives the usage context. The most important distinguishing fact ('Free', 'every data source') is front-loaded.

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

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

For a parameterless, read-only tool with no output schema, the description is nearly complete: it explains the return contents and when to use it. Minor gaps remain (e.g., how never-succeeded sources are represented, whether all sources are always listed), but none are critical for correct invocation.

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

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

The tool has zero parameters, so there is nothing for the description to document; the baseline is 4. The description compensates by explaining what the response contains, which is the only semantic content an agent needs for a parameterless call.

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 resource — freshness of every data source — and specifies the exact per-source fields returned (last successful snapshot/event, staleness in days, public URL). It clearly differentiates itself from the sibling asset-specific tools (spot_*, gpu_*, etc.) by being a cross-cutting status/meta tool, and the title 'Data freshness' reinforces the purpose.

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 final sentence gives an explicit decision context: use this to check whether a fixing or quote is current before paying for it, and the opening 'Free' implies it is the no-cost way to do this check. It provides clear context but does not name alternative tools or state when not to use it, 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?

Beyond the readOnlyHint/idempotentHint annotations, the description discloses the paid fee (0.05 USDC per call) and the exact computation: median across regions of each term's price divided by GPUs per node, with lo/hi bounds and discount to on-demand. It also discloses exclusions, which is exactly the behavioral context annotations cannot carry.

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 each sentence earns its place: cost warning, output definition, methodology, and exclusions. It is slightly telegraphic ("Term structure per hyperscaler...") rather than a clean verb-first sentence, but stays economical.

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 return-format burden and does so: it specifies terms (spot, on-demand, 1y, 3y), aggregation (median across regions), bounds (lo/hi), the derived discount, and the neo-cloud exclusion. For a one-parameter read-only tool, nothing needed 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 schema already documents `gpu` fully with examples and 100% coverage. The description reinforces that the model must have a hyperscaler mapping and that the output is per GPU-hour, but it adds no new parameter-level information, matching the baseline.

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

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

The description states the resource (term structure for one GPU model, per hyperscaler) and answers a concrete question ("what does a committed H100 cost against spot and on-demand, per cloud"). It does not explicitly differentiate from the sibling `term_instance`, so it stops short of full sibling-level clarity.

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

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

The description gives a clear use case ("Answers..."), includes a paid-call warning, and explicitly excludes neo-cloud quote-only commitments. It doesn't name alternative tools or state when not to use this one, so it is context-rich but lacks explicit when-not 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?

Beyond the readOnlyHint/idempotentHint annotations, the description adds significant behavioral context: the call costs 0.01 USDC, spot prices are 'median across zones (where spot events exist)', reserved terms are 'effective hourly with upfront amortised', and discount_pct is relative to on-demand. It also details provider-specific term configurations. This far exceeds what annotations alone 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?

The description is front-loaded with cost and scope, then follows with pricing methodology and provider-specific nuances. Every sentence adds substantive information, and there is no fluff. It is longer than ideal, but the density of useful detail justifies the length.

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

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

For a read-only, idempotent query with 3 self-explanatory parameters and no output schema, this description is complete. It tells the agent what the ladder contains, how prices are calculated, what the discount means, which reserved terms exist per provider, and even warns about the per-call cost. Nothing essential 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 schema already fully describes provider, region, and instance with 100% coverage. The description adds meaning beyond the schema by explaining how the result varies per provider (AWS four reserved terms, Azure two, GCP two) and by defining how discount_pct is computed. It does not repeat parameter formats, so it complements the schema nicely.

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 immediately defines the tool as a 'Price ladder for one instance type' covering spot, on-demand, 1-year and 3-year commitments with discounts. This clearly distinguishes it from broader or single-term siblings like `ondemand`, `reserved`, or `spot_latest`. However, it is phrased as a noun phrase rather than an explicit verb like 'retrieves' or 'returns', so it stops short of a fully specified action.

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 core use case is clear: when you need the full price ladder for exactly one instance type across all purchase terms, this is the tool. The phrase 'for one instance type' and the detailed list of terms gives a clear context. It does not explicitly name alternatives or say when not to use it, but the scope is well enough defined that an agent can infer it.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, covering safety. The description adds the cost (0.10 USDC per call) and the data scope (input, output, blended fixing, frontier basket). However, it does not disclose other potential behaviors like rate limits or response size, so it meets the baseline but adds limited extra 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 a single concise sentence with no fluff, and the cost is front-loaded. However, it is quite terse and could have been more explicit about what 'fixing' means, but it earns a 4 for efficiency.

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

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

Given the tool's simplicity (1 optional param, no output schema), the description covers the core data scope and cost. But terms like 'fixing' and 'frontier basket' are not explained, and without an output schema, agents may not know the exact return structure. The annotations fill in safety, so a 3 is reasonable, but it's not fully self-sufficient.

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

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

The schema fully documents the single parameter 'day' with format and default behavior, so coverage is 100%. The description adds no additional meaning for the parameter; it only mentions 'for one day' which aligns with the schema. Baseline of 3 is appropriate.

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

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

The description clearly identifies the resource: token fixing data for models (input, output, blended) for a given day, plus the frontier basket. However, it lacks an explicit verb and does not distinguish it from siblings like tokens_fixing or tokens_models, which are similarly named and likely related.

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 no guidance on when to choose this tool over alternatives. It does not mention that tokens_history is for historical trends, tokens_quotes for real-time quotes, or that this is a daily snapshot. The paid nature is mentioned, but not in a way that guides 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, destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it is a paid call (0.01 USDC per call), excludes batch/free variants, and defines the median calculation across sources and hosts. This goes beyond the annotations.

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

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

The description is compact and front-loaded with the most important operational fact (paid call), then explains the ticker semantics. Every sentence earns its place, though the ticker explanation is dense and could be slightly 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 read-only lookup tool with 2 params and full schema coverage, the description covers the key context: cost, exclusions, ticker semantics, and median methodology. It doesn't describe the return format, but there is no output schema and the tool is simple enough that the return shape is likely self-evident from the ticker semantics.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds meaning by explaining the ticker syntax and the .IN/.OUT/.BLEND semantics, which is helpful, but it doesn't add much beyond what the schema's example already conveys. 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+resource: it fixes one day's token price for a ticker like CX.TOK.CLAUDESONNET5.IN, and explains the ticker naming convention. It distinguishes itself from siblings like tokens_history and tokens_quotes by focusing on the daily fixing/median across sources.

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

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

The description explains the ticker format and the meaning of .IN/.OUT/.BLEND and FRONTIER, which tells the agent how to construct the required parameter. It doesn't explicitly say when to use this vs tokens_history/tokens_quotes, but the 'one day's token price fixing' framing implies a daily snapshot use case.

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. The description adds a critical behavioral fact: each call costs 0.05 USDC, and data starts on 2026-09-14. It does not mention pagination or response shape, but the annotation coverage lowers the burden.

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

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

The description is two compact clauses with no redundant wording. The cost warning is front-loaded, and the data scope is stated efficiently.

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

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

For a simple read-only history tool, the description plus schema covers cost, ticker, date format, and data start. However, it does not explain what a 'fixing' contains, how this differs from tokens_fixing, or what the return payload looks like, and there is no output schema to compensate.

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 parameters documented including date formats and a ticker example. The description adds no parameter-specific semantics beyond the general 'daily fixings' context, so the baseline of 3 is appropriate.

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

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

The description identifies the resource (token ticker), the data type (daily fixings), and the temporal scope (from first snapshot 2026-09-14). It is clear enough, though it does not explicitly distinguish itself from the sibling tokens_fixing tool.

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

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

No guidance is given on when to use this tool versus tokens_fixing, tokens_board, or tokens_quotes. The description mentions cost and data availability, but provides no exclusions, alternatives, or selection criteria.

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 convey read-only, idempotent, non-destructive, and open-world traits rejoined by the description's 'Free' note and 'today's price range' / 'seen today' framing, which clarifies the dynamic, time-bounded nature of the data. It also discloses what the response contains. It does not mention caching, pagination, or rate limits, but for a zero-parameter read-only tool the annotation coverage lowers the bar.

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, opening with 'Free' and immediately stating the scope. There is minor redundancy ('ticker codes' appears twice) and slightly awkward phrasing in 'a token price fixing', but overall every sentence adds useful 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 input parameters and no output schema, the description carries the full burden of explaining both behavior and return content. It does so thoroughly: canonical slugs, examples, ticker codes, source/host counts, min/max input and output prices, and the frontier basket. Nothing essential appears missing for an agent to invoke the tool correctly and interpret its 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 zero parameters, so there is no schema to elaborate on. The description's enumeration of what will be returned effectively substitutes for parameter-level guidance, matching the baseline score for a parameterless tool.

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

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

The description clearly states the resource (LLM models with token prices) and the specific verb-like intent: it lists all LLMs with token price fixing, canonical slugs, ticker codes, source/host counts, min/max input/output prices, and the frontier basket. This is sufficiently distinct from sibling tools like tokens_quotes or tokens_board, which focus on quotes or board data rather than the model catalog itself.

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

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

The description gives a clear implied use context: use this when you need a broad catalog of LLM token price data for today, including slugs, ticker codes, and price ranges. However, it does not explicitly state when not to use it or name alternatives such as tokens_history, tokens_quotes, or tokens_fixing, so routing among siblings is left mostly 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 the tool as read-only, idempotent, and non-destructive. The description adds crucial behavioral context: it is a paid tool costing 0.01 USDC per call, which is not captured in annotations. It also discloses that variants are marked in `extra.variant`, giving the agent insight into data structure. No contradictions.

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

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

The description is concise and well-organized. It leads with the cost (a critical decision factor), then explains the output scope and sources, and finally notes optional inclusions. Two sentences carry all necessary information with no redundancy, earning a top score.

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

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

Given the tool's simplicity (two params, read-only, no output schema), the description provides sufficient detail: it lists the sources, the fields included (cache-read price, context length), and how variants are marked. It lacks explicit mention of response format (e.g., array of rows), but that is a minor omission for a read-only quote 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?

Both parameters are fully described in the schema (100% coverage), so the baseline is 3. The description mentions 'one model on one day' but does not add new details about the parameters themselves (e.g., how to format `day` or validate `model`). It merely reiterates the tool's scope, adding no semantic value beyond the schema.

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

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

The description clearly states the tool returns price data for one model on one day across multiple sources, with specific fields like USD per million tokens. This differentiates it from sibling tools like tokens_history (which likely covers multiple days) and tokens_models (which lists model slugs). The verb 'retrieves' is implied through 'Every listed price...', and the resource is explicit.

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

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

The description explains what the tool does but provides no guidance on when to choose it over alternatives (e.g., tokens_history for trends or tokens_board for a summary). It doesn't mention exclusions or routing conditions, leaving the agent to infer usage from the scope ('one model on one day').

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