rust.wiki

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description still adds genuinely new context: the exclusion rule for seasonal/obsolete/unreleased items, the routing to shortname resolution, and a stated 15-minute cache aligned with the site's /items page. That cache and staleness disclosure is exactly the kind of behavioural trait annotations cannot express.

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, each carrying a distinct load: what it does and its scope, what each result contains plus where to go for more, and the ordering/cache contract. Scope and exclusions are front-loaded; nothing is redundant against the schema or 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?

With no output schema, the description correctly enumerates the returned fields (shortname, display_name, category, icon_url, is_craftable) and explains that richer data requires the detail endpoint. Combined with the cache TTL and exclusion rules, an agent can call this correctly; only pagination totals/result-count behaviour is unstated.

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 all five parameters (page, sort, search, category, per_page) are already fully documented including fuzzy-match semantics and ranking behaviour. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description opens with a specific verb+resource ('Browse or search the item catalogue') and immediately narrows the scope to 'one page of live items', which is a meaningful distinction. It signals a sibling boundary by pointing to `/items/{shortname}` for full details, though it never names get_item or search_items explicitly.

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

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

Usage is implied rather than stated: it explains that seasonal/obsolete/unreleased items are excluded from browsing but still resolve by shortname, and that the detail endpoint should be used for 'everything else'. There is no explicit statement of when to call browse_items versus search_items or get_item, so the agent must infer the routing.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the bar is lower. The description adds genuine value beyond them: 120-second per-filter-combination caching, that `price` is null when Steam has no listing, and that `total` is the filtered count.

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 purpose is front-loaded in the first sentence, and the field enumeration is dense but earns its place by defining return values. Some field descriptions partially overlap the schema, but the block is efficient for a 19-parameter tool.

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

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

There is no output schema, yet the description names essentially every returned field with its semantics, covering the burden annotations cannot. Combined with the caching and null-price caveats, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so every one of the 19 parameters is already documented in the schema. The description adds only the semantic that filters combine with AND, which the schema cannot express, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Browse skins') and enumerates the returned fields, so the agent knows this is a paginated listing endpoint. It stops short of naming sibling alternatives like search_skins or find_skin_deals, so the differentiation is by inference rather than 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?

Usage is implied ('Browse skins with the site's filters and sorts', 'Filters combine with AND') but there is no explicit when-to-use versus search_skins, get_item_skins, or find_skin_deals. The caching and null-price notes are helpful context but not routing guidance.

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

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

Annotations already declare this is a read-only, idempotent, non-destructive tool, and the description adds substantial behavioral detail beyond that: data is recomputed every ~5 minutes, stale buy orders above fresher asks are capped, Steam's 15% fee is reflected in net fields, and marketplace links are omitted.

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 first sentence is front-loaded and states the core purpose immediately. The remaining text is dense but justified because no output schema exists and the return fields need documentation, though the long inline field enumeration is heavier than ideal.

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 nine optional parameters, full schema coverage, no output schema, and read-only annotations, the description is complete: it documents the return fields, freshness cadence, fee treatment, profitability filter, stale-order handling, and missing marketplace links.

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

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

Schema description coverage is 100%, so parameter meanings are already well documented. The description still adds useful semantics around `steam_ref` outcomes, the effect of only returning profitable rows under that reference, and AND-combined filters.

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

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

The description opens with a precise verb-resource framing: executable buy-on-marketplace, sell-on-Steam flips. It further specifies the exact computation basis and profitability condition, so an agent can distinguish this from general skin pricing or browsing tools.

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

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

Usage context is clear: this tool returns only rows profitable under the chosen `steam_ref`, with filters combined by AND. However, it does not explicitly name when to use this instead of siblings such as `get_skin_price` or `get_market_movers`, so it lacks explicit alternatives/exclusions.

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

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

Annotations already declare this read-only, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: the response is cached for one hour, and it enumerates exactly what is returned (costs, up to ten durability entries per damage type, all grades Twig to Armored). It does not say what happens for a missing slug, which keeps it from a 5.

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

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

The content is dense but mostly earns its place, since field-level detail substitutes for a missing output schema. The opening sentence merely restates the title, and the rest is a single long run-on enumeration rather than being clearly partitioned by cost/durability/siblings.

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-value burden and does so thoroughly, including nested cost shapes (`amount` vs `min_amount`/`max_amount`) and the durability list caps. What is missing is failure behavior and sibling differentiation, both of which matter 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?

Only one parameter and the schema already documents it at 100% coverage, including the `stone-wall` example and the pointer to `/building`. The description adds nothing about the slug format or constraints, so it sits at the baseline for a fully-documented 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 makes clear this is a single-piece lookup keyed by slug, returning costs, durability and grade siblings. That is a specific resource with a specific payload. It does not explicitly distinguish itself from related siblings like get_raid_costs or get_upkeep_rules, so an agent must infer the boundary.

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 statement of when to call this versus get_raid_costs, get_upkeep_rules or get_world_entity, and no prerequisites or error conditions (e.g. unknown slug). The only usage-adjacent note is the one-hour cache. The agent gets payload detail but no 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, and the description adds meaningful context beyond that: the dataset size (12 monuments, 60 codes), the meaning of randomized suffixes, and the null slug behavior for Cargo Ship. This gives the agent enough behavioral context to interpret the data correctly.

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

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

The description is front-loaded with the core resource, then explains field meanings and edge cases in a compact sequence. Every sentence adds useful information, and there is no redundant or filler text.

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

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

There is no output schema, so the description must explain the returned data, and it does: it covers the monument count, code count, the `codes`, `randomized`, and `slug` fields, and the Cargo Ship null case. Nothing needed to call and interpret the tool 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, so there is no parameter semantics burden. Per the rubric, a parameterless tool receives a baseline of 4 when the schema is effectively complete.

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

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

The description states exactly what the tool returns: CCTV camera codes grouped by monument, with Computer Station identifiers. It is specific enough to distinguish this reference lookup from sibling tools like get_monument or list_monuments without opening the schema.

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

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

Usage is implied by the resource name and the note that this is fixed reference data, but the description never explicitly says when to use this tool versus get_monument or list_monuments. It provides no exclusions or alternative routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so safety is covered. The description goes further with a genuinely useful behavioral trait: results are read live from the database but cached for 60 seconds, which tells the agent the metadata itself can lag. It stops short of stating cost/latency or response shape, so it is strong but not maximal.

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 useful usage guidance is front-loaded and every sentence carries information. The opening phrase largely restates the title verbatim and the backtick-heavy prose is a little denser than needed, keeping it just under top marks.

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 metadata endpoint with no output schema, the description supplies everything an agent needs: what is returned, how fresh it is, and the polling pattern. There is no meaningful gap left to fill.

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 (100% coverage, additionalProperties false) already fully constrains the call. The description correctly adds no parameter detail because none exists – baseline 4 applies.

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

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

The description names the specific resource (per-dataset freshness metadata) and the exact fields returned: `updated_at` as the newest live timestamp in the table and `refresh_seconds` as its change cadence. This clearly separates it from the heavy data siblings such as /market/prices, /servers, and the browse_* family, so an agent can tell what it is without opening a schema.

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

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

It gives explicit when-to-use guidance ('poll this cheap endpoint') and when-not-to ('only re-fetch a heavy payload such as /market/prices or /servers when its dataset's updated_at has moved'), plus a caching rule for reference data. Alternative tools are named and the condition that selects them is spelled out.

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

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

Annotations only cover safety (readOnly/idempotent/non-destructive), and the description adds substantial context beyond that: a paid Steam call charged against the caller's own API key, the 24-hour cached-copy behavior, the `stale` fallback when Steam is unreachable, and `found:false` for private or empty inventories. These are exactly the behavioral traits an agent needs before committing to a billable call.

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

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

The opening clause is well front-loaded, but the middle is a dense unpunctuated wall of returned field names and flag lists that reads like a schema dump. Because there is no output schema the enumeration has value, yet it could be restructured into shorter sentences or a list.

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, annotations limited to safety, and a billable external call, the description does the heavy lifting well: return shape, auth, cost, caching, and failure modes are all covered. Missing only sibling routing and invalid-ID behavior.

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

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

Schema coverage is 100% and the single `steamid` parameter is already documented with an example and a pointer to /players/resolve, so the schema does the heavy lifting. The description only restates 'Takes a 17-digit SteamID64' without adding format, error, or validation semantics, which is the baseline case.

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

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

The description states a specific verb and resource ('Value a Steam account's Rust skins') and enumerates exactly what the response contains (per-skin quantity/price/value, totals, category shares, value_history). It is clearly distinct from the price-lookup and item tools, but it never explicitly separates itself from the near-identical siblings get_inventory_snapshot and list_inventory_snapshots, so an agent must infer the boundary.

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 (aggregate valuation of one account's holdings) and gives one hard precondition, the 17-digit SteamID64, but it never says when to prefer a snapshot or leaderboard sibling, nor when not to use it. The guidance is inferable rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds genuinely non-obvious context: values are re-priced on each view or by a daily warmer for the top 20, network-wide totals are included, and no API key is required. It omits only return-shape and ordering-stability details.

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 lead sentence front-loads the identity of the resource, and the following sentences add pricing behavior, page size, and auth facts. The parenthetical about re-pricing is dense but each clause carries information; slight redundancy with the title is the only waste.

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

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

For a single-optional-parameter read tool with no output schema, the description covers scale (20 per page), freshness semantics, auth requirement, and aggregate content — everything needed to call it correctly. Nothing material is missing.

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

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

Schema description coverage is 100% and the single 'page' parameter is fully documented in the schema, including the 20-per-page size. The description's '20 per page' merely restates the schema, adding no new semantics — baseline 3 applies.

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

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

The description states a specific resource (the rust.wiki/inventory leaderboard) and ranking rule (total value at last check), so an agent knows this lists top inventories globally rather than fetching one inventory like the get_inventory siblings. It doesn't explicitly contrast itself with get_inventory, get_inventory_snapshot, or list_inventory_snapshots, so sibling differentiation is only implicit.

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

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

Usage is implied by the leaderboard framing — use this to see top-valued inventories — but there is no explicit 'use when' statement and no exclusion pointing to get_inventory for a specific player's inventory. An agent can infer the purpose but must reason about alternatives on its own.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered; the description adds the useful 'No key needed' auth note and describes the payload contents. It does not say what happens when the date has no snapshot or how to discover valid dates (only implicitly via the schema's reference to the snapshots endpoint).

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

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

Front-loaded with the resource, then payload, then use case, then auth. Mostly efficient, though the opening sentence largely restates the title 'One saved daily snapshot' rather than adding 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 does so (items, quantity, day's price, total value, item count). Missing only edge-case behavior for a nonexistent date; for a 2-param read tool this is largely complete.

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

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

Schema description coverage is 100% — both date (ISO YYYY-MM-DD, sourced from the snapshots listing) and steamid (17-digit SteamID64) are fully documented in the schema. The description adds only the 'that day's price' framing for date; it says nothing about steamid, so baseline 3 applies.

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

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

The description states a specific resource (a single saved daily inventory snapshot) and enumerates its contents — items, quantities, that day's price, total value, item count. It's clear what is returned, but it never names the sibling it isn't (list_inventory_snapshots for enumerating dates, get_inventory for the current state), so sibling differentiation is left implicit.

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?

'Useful for "what was this worth last month" comparisons' implies a historical-comparison use case but gives no explicit when-not or routing rule to list_inventory_snapshots (to find dates) or get_inventory (for current values). The usage is inferable but not spelled out.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely non-obvious behavior: results are cached for 15 minutes, and `skins` is a capped preview of 24 with `skins_total` giving the full count. It does not say what happens for an unknown shortname, but the added context is solid.

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

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

The core purpose is front-loaded in the first sentence and field enumeration follows logically. The long parenthetical list of response fields is dense but every element earns its place given there is no output schema; minor tightening is possible.

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 describing the return shape, and it does so field by field — including ordering semantics ('highest chance first'), units (USD cents, chance_pct), and the capped-preview-plus-total pattern for skins. Nothing material is missing for a one-parameter read tool.

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

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

Schema coverage is 100% with an example (`rifle.ak`) already in the schema, so the description's only added signal is the incidental `/items/{shortname}/skins` reference, which confirms shortname is used as a path segment in related routes. Baseline 3 applies when 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?

States a specific resource and scope ('Full item detail bundle. Everything the item page shows, in one response') and enumerates the payload, so an agent knows exactly what this returns. It does not explicitly contrast itself with search_items/browse_items or get_item_skins, so sibling differentiation is only implied via the skins paging pointer.

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

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

Usage is implied by the description's scope — comprehensive single-item lookup keyed by shortname — but there is no explicit when-to-use or when-not guidance versus search_items, browse_items, or get_item_skins. The one routing hint is a pointer to `/items/{shortname}/skins` for the full skins list.

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 detail beyond the annotations: exact sort order, returned fields, USD-cent pricing, null price semantics, store-price fields, Workshop subscriber counts, flags, and cache/refresh timing. It does not contradict the read-only, idempotent 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 front-loaded with the core purpose and then supplies useful return-field and freshness details. It is somewhat dense and repeats the title in the first sentence, but most of the length earns its place because there is no output schema.

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

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

With no output schema, the description fully covers what the response contains, how it is ordered, pricing units and null values, and data freshness. It gives an agent enough context 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%, and the schema already documents shortname, page, and per_page. The description reinforces that shortname identifies one base item but adds no additional syntax or pagination 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 definition clearly states that it returns all skins for one base item, with pricing, and describes the ordering. It distinguishes the item-scoped list from broader skin tools implicitly via 'for an item' and the Skins tab comparison, though it does not name a specific sibling alternative.

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

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

Usage is implied by the item-scoped scope: use this when you have one item shortname and need its full skin list. However, it does not explicitly say when to use this instead of browse_skins, search_skins, get_skin, or get_skin_price.

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 read-only, idempotent, non-destructive and closed-world profile, and the description adds genuinely new behavior: 30-minute caching, Thursday rotation cadence with `next_rotation_at` = start + 7 days, and null `market_price` when an item is unlisted. What it does not cover, such as response size or pagination (there is none), is minor for a parameterless snapshot.

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

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

The opening clause front-loads the resource and the sections come before the long field enumeration, so an agent can stop reading early if it only needs the gist. The field list is dense but every token documents a real field; without an output schema this length is justified, though it could be trimmed by grouping 'the usual flags'.

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?

No output schema exists, so the description carries the return-value burden and does so thoroughly: every field group, the section semantics, rotation metadata, and even the Steam purchase URL template are spelled out. Combined with annotations covering safety, an agent has everything needed to call and interpret this 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 tool takes zero parameters, so there is nothing to disambiguate and the baseline applies. The description instead spends its space documenting the response fields, which is the more useful investment here.

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 first sentence plus 'What is purchasable in Rust's item store right now' gives a specific verb (retrieve) and resource with a clear temporal scope, and the three named sections (`limited_time`, `general`, `dlc_packs`) make the payload shape predictable. It does not explicitly distinguish itself from close siblings such as `get_store_rotation` or `get_item_store_history`, 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?

Usage is only implied: 'right now' and the 30-minute cache hint that this is the live snapshot, versus history/rotation siblings. No sentence says when to prefer this over `get_store_rotation`, `get_item` or `get_item_store_history`, and no prerequisites or exclusions are stated.

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

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

Annotations already establish readOnly/idempotent/non-destructive, and the description adds genuinely new context: ordering (newest first, open rotation included), DLC exclusion, a one-hour cache, and the fact that searches are computed live rather than served from that cache. It does not warn about payload size or pagination behavior despite returning every skin as {url, name} per rotation.

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 purpose leads and the detail follows in a single dense paragraph; the field enumeration earns its place because no output schema exists. Minor waste: a raw HTTP path (GET /store/rotations/{rotation_id}) is cited instead of the sibling tool an agent could actually call, and the awkward line break mid-backtick fragments the id-format sentence.

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

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

With no output schema, the description correctly compensates by describing every returned field and its semantics, including null end and null name. What is missing is guidance on result volume and paging for a response that carries every skin icon per rotation, which matters for a default of 50 and a max of 200.

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 page, per_page and search all documented including a maxLength and an example, so the baseline is 3. The description restates the search semantics ('only the rotations that sold a matching skin') but adds no format or edge-case detail beyond the schema, and says nothing about how paging interacts with the newest-first ordering.

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 first sentence names the specific resource (past item-store rotations) and the elaboration makes the returned shape concrete: newest-first weekly rotations including the open one, with a defined id format and DLC exclusion. It implicitly separates itself from the current-store and single-rotation siblings via the word 'Past' and the pointer to full item lists, but it never names those sibling tools, so an agent must infer the distinction.

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

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

The 'search' behavior is anchored to a concrete user question ('when was X in the store?'), which tells an agent exactly which situation calls for this parameter. It also redirects to another surface for full item lists, an implicit when-not. It stops short of naming get_item_store or get_store_rotation as alternatives, so the routing decision against siblings is left 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 cover read-only, idempotent, non-destructive behavior, and the description adds useful context: data is scraped from wiki.facepunch.com, cached for 30 minutes, and drops are ordered highest chance first. It does not cover error behavior or cache staleness beyond the 30-minute note, so it is strong but not fully exhaustive.

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

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

The description is front-loaded with the purpose, then uses the remaining space to enumerate return fields because no output schema exists. Despite the dense field list, every clause carries useful information and 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 single-parameter, read-only tool with no output schema, the description provides a complete return-shape overview and notes provenance and caching. The parameter source is already documented in the schema, so an agent has enough information to call the tool correctly.

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

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

Schema description coverage is 100% for the single source_id parameter, and the schema already explains that IDs come from loot tables, monuments, or an item's loot_sources. The prose adds little parameter-specific meaning beyond that, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific retrieval: one loot table for a loot source, including all drops and detailed fields. The 'one loot table' framing implicitly distinguishes it from list-oriented siblings, but it never names list_loot_sources or otherwise explicitly differentiates among alternatives.

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 returns but gives no explicit guidance on when to use it versus list_loot_sources or other lookups. The source_id schema description does indicate where IDs can come from, but the prose itself offers no when/when-not routing or alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, but the description adds meaningful context beyond them: a 15-minute cache, the rust.wiki source, inclusion rules (marketable skins with live Steam price and linked Workshop submission), and an explicit caveat that supply is approximated by Workshop subscriber count. That is a solid disclosure of data provenance and freshness, though it could say more about completeness or rate limits.

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?

It is front-loaded with the core purpose and then structured around field definitions and caveats, so no sentence is genuinely wasted. The second sentence is dense and could be broken up, but overall it is appropriately sized for a data-heavy tool.

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

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

With no output schema, the description carries the burden of explaining the return shape and does so clearly, including field meanings, value formula, inclusion criteria, and the approximation caveat. Minor ambiguity remains around whether `top` includes every skin or only a ranked subset, which keeps it from being fully complete.

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

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

The tool takes no parameters, so there is nothing to misinterpret; baseline 4 applies. The description instead spends its space documenting output fields, which is appropriate for a zero-parameter 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 states a specific resource ('Market cap of the Rust skin market') and concretely lists the return payload (`total_value`, `skin_count`, `by_category`, `top`), so an agent knows exactly what this tool produces. It does not explicitly contrast itself with siblings such as get_market_movers or get_skin_price, 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?

Usage is only implied by the data description; nothing says 'use this when you need the whole-market aggregate rather than individual skin prices' or names an alternative. The inclusion criteria and 15-minute cache give useful context but do not constitute when-to-use guidance.

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

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

Annotations already declare a read-only, idempotent, non-destructive, closed-world operation. The description adds meaningful behavior beyond that: the data refreshes about every 6 hours, skins with under 30 history points are excluded, and reference prices come from Steam's multi-year high/low history.

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 mostly front-loaded: it lists the three categories and then defines their fields and caveats. The opening phrase repeats the title, which is mildly redundant, but the remaining detail is useful rather than 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 and no parameters, the description carries the return-value burden well. It names each category and gives the fields returned for stonking/crashing and anticipated results, plus the refresh cadence and an important exclusion rule.

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 there are no parameter semantics to explain. This meets the baseline for a no-parameter tool, and the description does not introduce any unnecessary parameter-like 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 rust.wiki Insights page and clearly defines the three result categories: stonking, crashing, and anticipated skins. It is specific about counts and data meaning, though it does not explicitly distinguish itself from siblings like get_skin_price_history or find_skin_deals.

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

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

Usage is implied by the market-movers/Insights framing, but there is no explicit when-to-use guidance or named alternative. The agent can infer that this is for top gainers, losers, and anticipated skins, but must compare sibling names on its own.

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 (readOnly, idempotent, closed-world). The description adds genuinely new behavior: a one-hour cache, alphabetical ordering of `loot_sources`, and the exact fields returned (`id`, `name`, `drop_count`) — useful for deciding whether the data is fresh enough.

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?

Short and front-loaded: the core statement comes first, then the payload shape, then the cache note. Minor awkwardness from the mid-sentence line breaks, but no filler sentences.

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 the return value and does so for the distinctive part (`loot_sources` fields and ordering). The remaining monument fields are deferred to `/monuments` rather than enumerated, which is a small but real gap for an agent that cannot see that other response.

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

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

Schema coverage is 100% and the `slug` parameter already documents itself with an example (`airfield`) and a pointer to `/monuments`. The description adds no format or validation detail beyond the schema, so the baseline 3 applies.

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

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

States precisely what is returned: a single monument plus its `loot_sources`, and distinguishes it from the collection endpoint (`/monuments`). The distinction from `list_monuments` is implied through the endpoint reference rather than named directly, so an agent must map `/monuments` to `list_monuments` 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?

Makes clear this is the single-record counterpart to the list endpoint and tells the agent how to follow up on each loot source (`/loot-tables/{id}`). It does not state exclusions or prerequisites, but for a simple lookup the usage context is unambiguous.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely non-obvious behavior: a 24-hour cache, null sulfur/raw_cost for loot-only explosives like MLRS rockets, and a documented coverage gap for doors and deployables.

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 one-line summary is front-loaded and the field walkthrough is dense but purposeful, since there is no output schema to carry the return-value explanation. It is on the long side for a single-parameter tool, but nearly every clause carries information the agent can't get elsewhere.

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 and only one optional enum param, the description must carry the return-shape burden, and it does so thoroughly: top-level `explosives` fields, `targets`/`costs` nesting, `cheapest_staple`, null semantics, and known gaps. An agent has enough to call it and interpret results.

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

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

Schema description coverage is 100% and the single `grade` param is fully documented in the schema with an enum and example. The description explains what `targets` and `grade` mean in the payload but doesn't add filtering semantics beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource: a raid cost table listing explosives and sulfur per building piece, explicitly framed as 'the dataset behind the raid calculator'. That framing plus the field inventory makes it immediately distinguishable from siblings like get_building_piece or get_upkeep_rules.

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

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

It gives clear usage context (the raid calculator's dataset, and that a cheaper mix can be computed from `damage_per_unit` since damage adds up), plus an explicit exclusion: 'Doors and deployables are not covered yet'. It doesn't name an alternative sibling for those uncovered cases, so it stops short of 5.

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 that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds meaningful behavioral context beyond that: how wipes are detected, what each entry contains, the expected volume spike after Rust's monthly forced wipe, and the five-minute cache.

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

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

The description is front-loaded with the core purpose, then proceeds through detection logic, entry shape, volume expectation, and caching. Each sentence adds useful operational context without wasted wording.

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 three-parameter read-only feed with no output schema, the description is complete enough: it explains the return shape, detection basis, ordering, volume expectations, and cache behavior. An agent should be able to call it correctly without more information.

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

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

Schema description coverage is 100%, so the schema already documents page, hours, and per_page with defaults and bounds. The description reinforces the look-back-window concept and newest-first ordering, but does not add parameter-level semantics beyond what the schema provides.

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

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

The description states a specific resource and scope: recently wiped servers across every online server, newest first, matching a named public feed. It is clear what the tool returns and how a wipe is detected, though it does not explicitly distinguish itself from siblings such as get_server or search_servers.

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

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

Usage is implied by the description: use this to see recent wipe activity over a look-back window, and expect high volume after the monthly forced wipe. It does not explicitly say when to use this instead of get_server, search_servers, or get_data_freshness.

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

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

Annotations already declare read-only, idempotent, closed-world behavior, so the bar is lower. The description adds genuinely useful operational context beyond that: the feed is polled every few minutes and page 1 is refreshed immediately when a new post appears, which tells an agent the data is near-real-time and that results can shift between paginated calls.

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

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

Front-loaded with the purpose in the first clause before the field enumeration. The inline field list is dense but pays for itself by describing the return shape in a tool with no output schema; there is little wasted wording.

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 two-parameter read-only list tool with no output schema, the description covers purpose, source, ordering, freshness cadence, and enumerates all returned fields including the `has_blog_post`/`url` interaction. 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?

Schema coverage is 100% with both `page` and `per_page` documented (defaults, min/max) in the schema itself. The description adds no parameter-level meaning such as how ordering interacts with paging, so the baseline 3 applies.

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

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

Specific verb+resource: every post from rust.facepunch.com/news, newest first, with an explicit scope statement. No sibling tool covers this feed, and the description makes that unambiguous by naming the source domain and content domain (updates/devblogs).

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

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

Usage is implied rather than stated — an agent can infer this is the tool for Rust news/devblogs, but the description gives no explicit when/when-not cues or pointers to alternatives (e.g., get_data_freshness for cache state). With no closely overlapping siblings, the risk is low, but guidance is absent.

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 substantive behavior beyond the read-only/idempotent annotations: offline servers still resolve, unknown ids are 404, aggregates are cached five minutes, `next_wipe_estimate_at` is a heuristic not a schedule, and `map_preview` is null until a RustMaps render exists. This is exactly the context an agent can't get from structured fields.

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

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

It is front-loaded and free of filler, but the body is one long dash-chained sentence that mixes field enumeration with behavioral caveats, making it harder to scan than a short list would be.

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

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

With no output schema, the description must carry the return shape, and it does: it enumerates votes, rating, wipes, wipe-cycle estimates, force-wipe timing, and every map_preview subfield including nullability. An agent has everything needed to call it and interpret the result.

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

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

Schema description coverage is 100% and the single `server_id` parameter is fully documented in the schema, including its source URL. The description adds no additional meaning about the id beyond what the schema already states, so baseline 3 applies.

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

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

The definition names the exact resource and scope ('One server in full', 'the full public record') and enumerates the returned fields, so an agent can distinguish it from list tools like search_servers or get_top_servers. It never uses an explicit retrieval verb, but the intent is 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?

Usage is only implied: it's for a single server identified by id, and the description points to `/servers/{id}/history` for a different data need. There is no explicit 'use this instead of search_servers when...' routing or precondition statement.

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?

With readOnly/idempotent annotations already covering the safety profile, the description goes well beyond them: it discloses that the headline price refreshes more often than the order-book ladders so they can briefly trail it, that sale_basis=false means the points are ask-price readings rather than real sales, that market_stats is a frozen September 2026 SCMM snapshot and is null for uncovered skins. These are exactly the caveats an agent needs to interpret the payload correctly.

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?

It is front-loaded with the one-line summary, which is good, but the remainder is a dense run-on catalogue of every response field (some of it truncated mid-word at '`cros'), which reads more like schema documentation than guidance. The field list earns some of its place given no output schema, but it is heavier than needed.

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 values, and it does so thoroughly for skin, price, orderbook, steam_history and market_stats, including null semantics. It is cut off mid-sentence ('`cros' for cross-market prices), so the cross-market portion is left unexplained.

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?

There is a single parameter and schema description coverage is 100%, with the schema itself explaining that itemdefid is the Steam item definition id and the rust.wiki URL segment. The prose adds nothing further about the parameter, so the baseline 3 applies.

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

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

The opening sentence names the resource and enumerates exactly what comes back (price, order book, history, cross-market prices), so an agent knows this is the comprehensive skin lookup rather than a narrow price call. It never names the siblings it supersedes (get_skin_price, get_skin_price_history, get_skin_collection), leaving differentiation to inference from 'Full skin detail.'

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

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

Usage is only implied: the field inventory makes clear this is the everything-at-once call, and 'wider ranges via /skins/{itemdefid}/history' points at a deeper history path. There is no explicit when-to-use/when-not statement and no mention that get_skin_price or get_skin_price_history are the lighter 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 readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds real value by disclosing a 30-minute cache and the ordering of returned skins (price descending), which are behavioral traits an agent could not infer from annotations or schema.

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

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

The definition is front-loaded with the core resource, then returns details, a cross-reference, and caching. The field enumeration is dense but productive. It is appropriately sized, with no filler, though the embedded field list is slightly run-on.

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?

No output schema exists, so the description correctly carries the return-shape burden: it names the collection fields, defines `released`, and specifies the skin object shape and ordering. Combined with annotations covering safety and a fully specified slug parameter, this is nearly complete, lacking only edge-case behavior such as invalid slugs.

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?

There is only one parameter and the schema description coverage is 100%, with the slug format and example already fully documented. The description adds no additional parameter semantics, so baseline 3 is appropriate for a high-coverage single-param schema.

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

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

The description identifies a specific resource — one collection plus all its member skins — and lists the returned fields, making the purpose concrete. It implicitly distinguishes itself from the sibling list_skin_collections by being singular, but it does not explicitly name that sibling or state verb+resource in the first sentence.

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

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

Usage is only implied: the tool fetches a collection by slug. The description does point out that value-over-time lives at GET /market/collection-value, which is useful routing, but it never says when to choose this over list_skin_collections or get_skin. No explicit exclusions or prerequisites 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?

Beyond the read-only and idempotent annotations, the description discloses the 5-minute cache, explains how the canonical wiki price is derived, defines ask/bid sides, describes ladder ordering, and specifies null behavior for change fields and sales_30d. This adds substantial behavioral context not covered by annotations.

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

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

The first sentence front-loads the core purpose, and the remaining text systematically documents return fields. It is dense but well-structured; nearly every sentence earns its place, though the long enumeration of fields is 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?

There is no output schema, so the description carries the full burden of explaining return values. It does this thoroughly, covering all named fields, units, nullability, ordering, and caching behavior, leaving no obvious gap for an agent to call and interpret the result 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?

The single itemdefid parameter is fully documented in the schema, including an example. The description does not add meaning beyond describing that the tool operates on 'one skin,' so the high schema coverage justifies the baseline score of 3.

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

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

The description opens with a precise verb-and-resource statement: live price, order book depth, extremes, and 7d/30d change for one skin. It distinguishes itself from siblings like get_skin and get_skin_price_history by emphasizing live pricing and the compact '/price' card 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?

It gives clear context that this is the data equivalent of the Discord bot's /price command and notes the 5-minute cache. However, it does not explicitly say when to prefer this over get_skin_price_history or get_skin, nor does it state exclusions.

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

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

With annotations already covering readOnly/idempotent safety, the description goes well beyond them: it discloses the point structure (recorded_at, price, volume), that price is in cents and represents a median, the resolution policy (hourly for the recent month, daily beyond, one point per day for ranges of a year or more), how far back history reaches (2015), the empty-result condition, and the one-hour cache. This is exactly the behavioral context an agent needs before calling.

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 purpose is front-loaded in the first sentence, and the dense detail that follows is mostly load-bearing. Some of the granularity/caching detail could be tightened, and the mid-sentence line breaks make it slightly harder to scan.

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

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

There is no output schema, so the description must carry the return shape, and it does: field names, units (cents), semantics of price and volume, and the granularity variations. Combined with the disclosed failure mode and cache behavior, an agent has everything needed to call and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics the enum cannot: it explains that longer ranges change granularity and aggregation (median price, summed volume), which affects how the caller should interpret `range`. The itemdefid parameter gains no explanation 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 title and first sentence state a specific verb+resource: Steam sale history for one skin, sourced from Steam Community Market's listing page. It is distinguishable from get_skin_price by the word 'history', but it never explicitly contrasts with that sibling or with get_item_store_history, leaving the agent to infer the boundary.

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

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

Usage is only implied by the description of what the series contains. The one exclusion stated ('Empty when Steam has no sale series... unmarketable skins') concerns result emptiness, not when to choose this tool over get_skin_price or get_item_store_history. No explicit when-to-use guidance is given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new behavioral context: a one-hour cache, and the caveat that a past rotation can still hold evergreen catalogue items whose `market_price` and `is_available_on_store` reflect today rather than the rotation date. That temporal caveat meaningfully guards against misinterpretation.

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

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

The core statement is front-loaded in one short sentence, followed by the payload breakdown. The inline field enumeration is compact, though the long parenthetical about itemdefid_count and evergreen items makes the second sentence heavy for what it conveys.

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

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

With no output schema, the description does the heavy lifting by describing the return envelope, item buckets and shared item shape. Only the pagination/size characteristics are unaddressed, which for a single-rotation lookup is a minor omission.

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

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

Schema coverage is 100% and the parameter already carries an example, maxLength and a description pointing to /store/history. The description's field listing describes the response, not the `rotation_id` input, so it adds little semantic value beyond the schema — baseline 3.

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

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

The description states a specific resource ('one rotation's full item list') and enumerates the rotation envelope fields plus the three item buckets, so an agent knows exactly what comes back. It does not name a sibling to contrast with, though 'One rotation as the wiki's /store/rotation page shows it' implicitly separates it from get_item_store history/browse tools.

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

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

Usage is implied rather than stated: the id format 'from /store/history' hints at the prerequisite call without naming get_item_store_history as an alternative. There are no explicit when-not-to-use rules or stated alternatives, so the agent must infer 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 cover read-only/idempotent/no-destruction, so the description's added value is the caching disclosure ('Cached for 60 seconds') and the compact-vs-full record distinction. That's genuinely useful context beyond the annotations, though it doesn't say anything about ordering ties or what happens at limits.

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

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

Front-loaded with the key statement and the field list is compact. The rust.wiki Discord bot reference is mildly superfluous detail but doesn't obscure the purpose.

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

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

No output schema exists, yet the description enumerates exactly the returned fields (id, name, players, max_players, country, url), and adds the caching note. An agent has everything it needs to call this 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 both parameters (limit, country) are already fully documented with ranges and patterns. The description adds no parameter-level meaning beyond the schema, which is the expected 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?

States a specific verb+resource with scope: 'most populated servers right now'. It is clearly distinct from get_server (single server) and search_servers (filtered search), so an agent can pick it without opening a schema.

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

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

Points to '/servers?sort=players for the full records', giving a clear alternative for the heavier use case. It doesn't explicitly name the sibling tools (search_servers) or spell out when not to use it, so it stops short of full routing guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description adds real context beyond them: the values are fixed constants of the dedicated-server default profile (subject to per-server ConVar overrides) and no computation happens server-side — meaningful caveats for interpreting the numbers.

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 first sentence front-loads the topic and the bracket math follows in a single dense but ordered pass. It is longer than a typical description, but with no output schema the enumeration of bracket tiers and `decay_hours` earns its space.

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

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

With no output schema and no parameters, the description carries the burden of explaining return contents, and it does: bracket boundaries, blended-rate semantics, per-grade decay durations, and the `blocks` null = unbounded convention. Only minor gaps remain (exact field names/types of the response envelope, whether values are per-grade keyed objects).

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, which sets the baseline at 4 under the rubric. Nothing in the description contradicts or muddies that.

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 data resource — upkeep decay brackets and decay times — and enumerates the exact fields (`brackets`, `decay_hours`) and ConVars it reports, so an agent can tell this is a static constants lookup distinct from tools like get_raid_costs or get_building_piece. It lacks an explicit verb ("returns"/"fetches") and never directly names a sibling, which keeps it just 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?

Usage is only implied: an agent can infer this is for reasoning about base upkeep costs, and the note "as most servers run them" hints at when the defaults apply. No explicit when-to-use, when-not-to-use, or alternative tool is offered, so guidance remains minimal.

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

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

Annotations already cover readOnly/idempotent, so credit goes for the extras: a one-hour cache window (an agent knows results can be stale), `loot_source_id` being null when the entity drops nothing, and `drops` being capped at five with `drop_count` giving the true total. It does not mention auth requirements or failure behavior for an unknown slug.

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

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

Front-loaded with the one-line purpose, then the return shape, then the pointer to the full table and the cache note. The field enumeration is long but each field name earns its place given there is no output schema; only the line wrap inside the sentence is awkward.

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 contract itself and does so thoroughly: entity fields, null semantics, the five-drop cap, the total count, and where to get the rest. For a one-parameter read tool with full annotation coverage, nothing an agent needs is missing.

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

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

Schema coverage is 100% and the single `slug` parameter is fully documented there (including the `bear` example and length bounds), so the description adds no parameter-level information. Baseline 3 applies when the schema does the work.

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

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

States a specific verb+resource: fetch a single world entity (by slug) together with its loot, and enumerates exactly what comes back. It reads clearly as the single-entity counterpart to search_world_entities, but it never names that sibling, so differentiation is inferred rather than stated.

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

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

Usage is only implied: 'One world entity' signals lookup-by-slug versus the search/list siblings, and the trailing pointer to `/loot-tables/{loot_source_id}` effectively routes the agent to get_loot_table when the top-five drops are insufficient. There is no explicit when-to-use/when-not statement.

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 (readOnly, idempotent, non-destructive, closed world), yet the description adds real behavioral detail beyond them: newest-first ordering, a 400-date cap, the write-trigger condition, and the coverage limitation (only looked-up inventories). That is substantial value-add.

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

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

Front-loaded with a headline sentence, then the operational details. Slight redundancy between the title/opening and the second sentence ('Every date … on which a daily snapshot of this inventory was stored'), but overall efficient and information-dense.

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

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

For a simple, single-parameter list tool with full annotation coverage and a clear next step, nothing critical is missing: ordering, cap, trigger, coverage caveat and the fetch follow-up are all stated.

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

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

Only one parameter (steamid) and schema description coverage is 100%, so the schema already documents it fully as a 17-digit SteamID64. The description adds a URL template but nothing about the parameter itself, so baseline 3 applies.

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

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

States a specific verb+resource: lists dates for which a daily inventory snapshot exists. It explicitly routes the agent to the fetch endpoint (/inventory/{steamid}/snapshots/{date}), i.e. the sibling get_inventory_snapshot, so the distinction is clear without opening either schema.

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

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

Provides clear context: snapshots are written on lookup, and only inventories someone has looked up will have any. It also hints at the follow-up action (fetch one via the date endpoint). It stops short of an explicit 'use this instead of X when…' exclusion, keeping it at 4.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the description earns credit for what it adds: alphabetical ordering, one-page-at-a-time pagination, and a 30-minute cache TTL. The cache note is genuinely useful invocation context. It doesn't say whether total page counts are returned or how to detect the last page.

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?

Roughly four dense sentences, all front-loaded with scope before field details, and every sentence carries information (field names, alternative endpoint, cache window). The field enumeration is a bit compressed but not wasteful.

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

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

There is no output schema, so describing the returned fields (id, name, drop_count, icons with 'four likeliest drops') is exactly the right compensation and makes the result interpretable. Combined with the annotations and the alternative-endpoint pointer, an agent has enough to call it correctly; only end-of-pagination behavior is unclear.

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 both parameters (page, per_page with defaults and max 200) are fully documented in the schema. The description only implies pagination via 'One page of loot sources' and adds no syntax or format detail beyond the schema. Baseline 3 is correct when the schema carries the load.

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 resource precisely ('Every loot source (crates, NPCs, barrels)') and scopes it to one alphabetical page. It also distinguishes itself from get_loot_table by routing per-source drop data to '/loot-tables/{id}'. It stops short of a full 5 only because the leading sentence has no explicit verb ('list'), reading more like a label than an action statement.

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 implicitly frames this as the browse-all path while pointing to get_loot_table for full drop tables, which gives an agent a real routing decision. It doesn't state exclusions or when to prefer a search sibling, but among its siblings none covers loot sources, so the gap is small.

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 substantial context beyond annotations: the set is fixed at 60, results come back alphabetically in a single response with no pagination, and data is cached for one hour. Annotations already cover read-only/idempotent safety, so the remaining disclosure is appropriately handled.

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

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

Front-loaded with the core fact and set size, then the returned fields. The long field enumeration is justified because no output schema exists, though the run-on sentence could be tightened.

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 compensates by enumerating every returned field (slug, name, tier, is_safezone, radiation flags, recyclers, tunnel/chinook/crash flags, no_build_area_sqm, icon_url). Nothing an agent needs to call or interpret the result 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?

Zero parameters, so the baseline is 4; the description correctly implies no filtering or paging arguments exist.

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

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

States a specific verb+resource (list all fixed monuments) plus scope qualifiers: fixed-location only, alphabetical, complete set of 60, no pagination. Distinguishes clearly from the singular get_monument and from search_world_entities by naming what is excluded (moving monuments / Cargo Ship).

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

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

Gives clear selection context: use this for the full static set in one call since it is not paginated, and moving monuments are explicitly out of scope. It does not explicitly route to get_monument for per-monument detail, so it stops short of full alternative guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real context beyond them: a 30-minute cache, the ~750 row magnitude, value units in cents computed over priced members only, and null avg_value semantics when nothing is priced. It does not warn about response size (icons embedded per member across up to 200 rows per page), which is the one material omission for a read 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?

Front-loaded with purpose and scope, then field semantics, then a slug-derivation note useful for follow-up calls; nearly every clause carries information. It runs long for a list tool and the slug paragraph, while helpful, is about a different endpoint.

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

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

There is no output schema, and the description compensates fully by documenting the return shape field-by-field (name, count, total_value, avg_value, icons with {url, name}), units, null conditions, and cardinality. An agent can construct and interpret the call without opening anything else.

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

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

Schema description coverage is 100% and the sort enum is already documented in the schema, so the schema carries the parameter burden. The description clarifies value semantics ('cents, over the priced members only') which does aid interpretation of value_* sorting, but it adds nothing about page/per_page behavior; baseline 3 applies.

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

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

The description names the resource and its full scope ('Every skin collection (about 750)') and enumerates the returned fields, so an agent knows this is an exhaustive listing rather than a lookup. The reference to GET /skins/collections/{slug} implicitly points at the singular detail sibling, but get_skin_collection is never named, so differentiation is inferential rather than 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?

Usage is only implied: the phrase 'Every skin collection' suggests bulk enumeration versus a single-collection fetch, but there is no explicit 'use this when / use get_skin_collection instead when' guidance. With 35 sibling tools including search_skins and get_skin_collection, an explicit routing sentence would have earned a higher score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is clear. The description adds useful behavior beyond annotations, including a 30-minute cache, the exact fields returned, category namespace semantics, and the meaning of permission_required being null.

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 front-loads the core purpose and then compactly lists the returned fields, which is especially valuable because there is no output schema. Every sentence contributes useful information without unnecessary verbosity.

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

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

Given that there is no output schema, the description does a good job explaining the returned fields and caching behavior. Combined with annotations and a fully documented input schema, it gives enough context to call the tool correctly, though it could mention result count or pagination metadata.

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 page, search, per_page, and admin_only are already well documented in the schema. The description does not add parameter-specific guidance beyond the structured fields, which is acceptable at baseline 3 when 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 Rust console/server commands and states that results are returned one page at a time in alphabetical order. It does not explicitly name sibling tools like search_servers or search_items for differentiation, but the domain is specific enough that an agent can distinguish it from item, skin, server, and workshop search tools.

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

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

The description does not say when to use search_commands versus alternatives, nor does it name any sibling tool or exclusion condition. The paginated, alphabetical framing implies a browse/search use case, but no explicit usage guidance is provided.

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

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

Annotations already mark it read-only/idempotent/non-destructive, and the description adds real substance on top: the 25-result cap, ranking order, dual matching strategy (case-insensitive substring on display name OR shortname, plus trigram similarity so typos resolve), the concrete `asault` → Assault Rifle example, 5-minute caching per query, and the exact result shape. This is well beyond what the annotations provide.

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

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

Purpose and cap are front-loaded, then matching semantics, then the escape hatch to other endpoints. Nearly every clause earns its place; the 'same ILIKE + similarity search the site's item pickers use' aside is minor color that could be trimmed, and the prose is dense in a single block.

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 compensates by spelling out the result object fields `{shortname, display_name, category, icon_url}` and the cap on result count. Combined with the caching note and the follow-up call path, an agent has everything needed to invoke it and use the response 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% and documents the single `q` parameter, so the baseline is 3. The description goes further by explaining what `q` actually matches against — display name OR shortname, substring plus fuzzy trigram similarity — which the schema does not state and which materially shapes good query construction.

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

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

States a specific verb (typeahead search) and resource (item display name / shortname) and immediately bounds the result set to 25. It is clearly separable from get_item (fetch one by shortname), browse_items (browse), and search_skins (a different resource).

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

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

Explicitly routes the agent: this tool for live typeahead, `/items?search=` for filtered/paginated results, and `/items/{shortname}` for follow-up. The alternative referenced is a REST route rather than a named sibling tool (e.g. browse_items), so the in-tool routing is slightly less crisp than it could be, but the when-to-use condition 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?

The annotations already cover read-only, idempotent, non-destructive, and closed-world behavior, but the description adds useful details: a five-minute cache, stable pagination via id tie-breaking, and truncation of owner descriptions to 500 characters. It does not mention rate limits or auth requirements, but the added context is meaningful beyond the structured 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 purpose is front-loaded in the first sentence, and the pagination stability note is useful. Most of the text enumerates the full public server record, which is dense but justified because there is no output schema; it could be structured more readably, but little of it is pure 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?

Given 13 parameters, no output schema, and a complex filterable list operation, the description is complete enough for an agent to call it correctly. It documents filtering behavior, cache behavior, pagination stability, and the full result record, leaving no major gap for selection or invocation.

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

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

Schema description coverage is 100%, so every parameter already has enum values, defaults, ranges, and descriptions. The prose only says the tool uses the same filters and ordering as the website list and hub pages, without adding syntax or edge-case meaning beyond the schema, so the 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 opens with a specific verb and resource: browse, filter, and search the server list, and it clarifies that results are one page of full server records. It clearly distinguishes a list/search operation from a single-server lookup, though it does not explicitly name siblings such as get_server or get_top_servers.

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

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

Usage is implied by the opening verb and by the reference to filters, ordering, and hub pages such as /country/de and /vanilla. However, it gives no explicit when-to-use or when-not-to-use guidance versus get_server or get_top_servers, so an agent must infer the choice from the tool name and 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?

Annotations already cover the read-only, idempotent, non-destructive profile, and the description adds real context beyond them: result cap of 10, best-match ordering, and the ILIKE+trigram matching semantics. It also discloses the exact return shape, which matters since there is no output schema.

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

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

Three tight sentences, front-loaded with what the tool is and what it returns. The alternative-usage note is placed last where it belongs. No wasted text.

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 compensates fully by enumerating the return fields `{itemdefid, name, icon_url}` and the ordering guarantee. For a one-parameter read tool, nothing an agent needs to invoke or interpret the result is missing.

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

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

Schema coverage is 100% and the single `q` param is fully documented in the schema (min 2, max 100 chars). The description adds meaning beyond that by clarifying that `q` matches against skin *names* via substring/trigram matching and that results are ranked by match quality.

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

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

States a specific verb+resource (skin name typeahead) plus concrete scope: up to 10 skins, matched on `q`, best match first. An agent can distinguish this from browse_skins or search_items immediately.

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

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

Explicitly says to use the returned `itemdefid` with the other skin endpoints, and routes filtered/paginated needs to GET /skins with `search=`. The only friction is that the alternative is named as a raw REST endpoint rather than the sibling tool name (browse_skins), requiring a small 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 read-only, idempotent, non-destructive, closed-world behavior, so the description correctly spends its words elsewhere: it discloses pagination ('One page of submissions'), nullable fields (submitted_at, subscriptions, vote_score 'null when Steam has not reported them'), and a shared cache/ordering model with the /workshop page. The '/workshop page' reference is a bit opaque to an agent with no web 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?

Purpose is front-loaded in the first sentence, with field documentation following. The field list is dense but each item carries real semantic payload (including the `/skins/{itemdefid}` cross-reference); the run-on structure with nested parentheticals makes it slightly harder 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?

With no output schema, the description appropriately takes on the return-shape burden by enumerating every field and its meaning, including nullability and the accepted_itemdefid-to-/skins linkage. What is missing is modest: total page counts / whether pagination end is signaled, and explicit filter-combination behavior.

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

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

Schema coverage is 100% with enums and examples for all six params, so the schema does the heavy lifting and the baseline of 3 applies. The description's filter mention is generic and does not add format or interaction detail (e.g., how search and target combine) 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?

Opens with a specific verb+resource ('Browse or search Workshop submissions') and immediately clarifies the unit of return ('One page of submissions'). No sibling tool covers Workshop submissions, so the absence of explicit sibling differentiation costs little, but the dual 'browse or search' framing is not resolved into distinct modes.

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?

'Browse or search' plus the filter list implies usage, and the pointer to '/workshop/targets' for valid target values is a useful routing hint. However, there is no explicit statement of when to prefer this over related tools or what happens with an over-long/empty search, leaving selection mostly 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 readOnly, idempotent, non-destructive behavior, so the bar is lower, yet the description adds real value: it discloses the one-hour cache, alphabetical ordering, and the exact fields returned per entity (including npc_hp being null for resources). It does not mention rate limits or what happens at page boundaries, keeping it from a 5.

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

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

Short, front-loaded paragraph with the entity scope first and supporting detail after. The opening clause 'World entities: animals, NPCs, resource nodes' repeats the title verbatim, which is mild redundancy, but otherwise every sentence carries information.

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

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

With no output schema, the description appropriately compensates by enumerating the returned fields (slug, display_name, is_npc, npc_hp, icon_url) and noting the cache lifetime. Pagination semantics are left to the schema, which documents them fully, so the definition is essentially complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, with kind, page, search, and per_page all documented in the schema including an enum explanation. The description adds no parameter-level detail beyond what the schema already supplies, so the baseline 3 applies.

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

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

States a specific verb-and-resource combination ('One page of world entities') and clarifies scope ('anything not tied to one monument'), which distinguishes it from the single-entity sibling get_world_entity. It falls short of a 5 because the search/filter capability implied by the tool name is not surfaced as the primary 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?

Usage is only implied: the phrase 'one page of world entities ... alphabetical' suggests listing/browsing, and the scoping note hints it is not for monument-bound entities. There is no explicit guidance on when to prefer this over search_items, list_monuments, or get_world_entity.

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