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

Annotations already declare the safety profile (readOnly=false, destructive=false, idempotent=true, openWorld=false), so the bar is lower. The description usefully names exactly which caches are affected and that they are in-memory (non-persistent), which is real added context; it stops short of stating the consequence (subsequent calls will refetch from upstream APIs).

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

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

A single front-loaded sentence with the action first and the scope second. Every word earns its place; nothing is padded or redundant.

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 maintenance utility with no output schema, the description covers the essential information: what is cleared and that it is the server's in-memory cache. It could add a sentence on expected effect (cache refill on next request) but nothing critical is missing for correct invocation.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly introduces no parameter discussion, since there is nothing to document beyond the schema's empty properties object.

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 ('Clear') and a precisely scoped resource ('this MCP server's in-memory Hypixel, Mojang, and wiki response caches'). No sibling tool touches caches, so an agent can immediately tell this apart from the resolve/skyblock/wiki lookup tools.

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

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

There is no when-to-use guidance at all: no indication of when a caller should invalidate caches (e.g., after data changes, before a freshness-critical query), no mention of cost, and no alternative to compare against. The agent must infer usage entirely.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description adds useful context about the input encoding and the two-part output shape, but says nothing about failure behavior on malformed/corrupt Base64-gzip payloads or the input size limit that constrains large payloads.

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

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

A single front-loaded sentence with no filler; the decode operation, the input format, and the output shape are all stated without redundancy.

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

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

There is no output schema, so the description's brief note about returning plain JSON plus a compact item list is helpful, and annotations carry the safety profile. However, for a 3-parameter transform tool with 0% schema coverage, the definition is not complete enough: parameter behavior and error handling are left entirely unspecified.

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

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

Schema description coverage is 0% and three parameters (data, maxItems, includeRaw) are undocumented in both schema and description. The mention of 'plain JSON and a compact item list' only loosely gestures at includeRaw and maxItems; it never states that maxItems caps the item list or what includeRaw toggles.

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?

Names a specific verb (decode) applied to a precise resource (a Hypixel SkyBlock base64 gzipped NBT inventory/item payload) and states the produced artifacts (plain JSON and a compact item list). No sibling in the list performs this same transform, so an agent can identify it 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?

Usage is only implied by the input type ('base64 gzipped NBT payload'), which suggests 'use this when you already hold raw NBT'. There is no explicit when-to-use, no when-not-to-use, and no guidance on how this relates to siblings like skyblock_inventory or skyblock_storage that likely surface similar item data.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description usefully adds the API-key requirement and implies external network dependency, but says nothing about rate limits, failure behavior for unknown players, or response shape.

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

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

A single front-loaded sentence naming the resource and its contents, followed immediately by the auth prerequisite. No padding or redundancy.

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

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

With no output schema, the field enumeration (status, rank, login times, karma, stats) usefully sets return-value expectations, and annotations carry the safety semantics. Only the vague phrase 'selected network stats' and the absent sibling routing keep it short of 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% and both parameters (uuid, username) carry their own descriptions including the dashed/undashed format. The description adds no parameter-level detail, which is the expected baseline 3 when the schema does that 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?

Specific verb (Fetch) plus resource (Hypixel network player data) with an explicit enumeration of returned fields (online status, rank, login times, karma, network stats). This lets an agent distinguish it from generic player endpoints, though it never names resolve_player or explains how the two divide labor.

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 only guidance is the prerequisite 'Requires HYPIXEL_API_KEY'. There is no statement of when to call this versus resolve_player, nor whether uuid or username should be supplied, so the agent must infer routing from the schema.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, covering the safety and idempotency profile. The description only adds that the output is normalized UUID form(s), without detailing formats, error behavior, or whether resolution may fail for unknown names.

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

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

A single, front-loaded sentence with no padding. It is efficient, though terse enough that more operational detail could have been added without bloat.

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 'normalized UUID forms' remains vague — it doesn't say which forms (dashed/undashed) or whether both are returned. The core contract (accept either identifier, return UUIDs) is conveyed but incompletely.

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

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

Schema description coverage is 100%, so the schema already documents both uuid and username with format hints. The description adds only that either identifier is acceptable and gets normalized, which is essentially restating the schema's purpose.

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 (resolve) and resource (Minecraft username or UUID) with an explicit outcome (normalized UUID forms). However, it does not differentiate itself from siblings like hypixel_player, so an agent gets no routing signal from the description itself.

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

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

The phrase 'for Hypixel tools' implies the usage context (a preprocessing step before other Hypixel queries), but there is no explicit when-to-use vs when-not, no named alternative, and no prerequisites 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/destructive=false and openWorld=false, so the safety profile is covered. The description goes beyond them by asserting no API requests are made and credentials are never revealed, which materially clarifies the local, secret-free behavior.

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

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

Two tight sentences that front-load the returned data and then the two safety guarantees. Every clause earns its place with no redundancy.

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

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

With no parameters, no output schema, and full annotation coverage, the description supplies enough to call the tool correctly and understand its scope. A brief note on the shape of the returned integrations/cache data would be the only marginal addition.

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 for the description to disambiguate; the baseline for a no-argument tool applies. The description correctly implies no input is required.

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 ('Inspect') and enumerates the exact resources returned: server version, configured integrations, and cache use. This is immediately distinguishable from every sibling, all of which fetch remote Hypixel/Skyblock data or clear the cache.

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 local nature of the tool ('locally'), but the description never states when to prefer it, e.g. for diagnostics or verifying configuration before other calls. No alternatives are named, though sibling overlap is minimal.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that 'lookup' is an API-key path and that output is filtered unless raw is requested, which is genuinely useful behavioral context. It does not, however, describe pagination behavior or result caps, so it is helpful but not rich.

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

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

Two tight sentences that front-load the mode list before the lookup dimensions. The closing clause 'Filters output for AI use' is vague filler that does not earn its place, but the overall size is appropriate for the tool's surface.

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 12-parameter, zero-coverage, no-output-schema tool, the description is too thin to let an agent call it correctly. It never explains how mode interacts with page/limit/binOnly/category, nor what the filtered result shape looks like, leaving key invocation decisions to guesswork.

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

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

Schema description coverage is 0% across 12 parameters, so the description carries the full explanatory burden. It clarifies only the mode enum and the auction/player/profile lookup identifiers; page, limit, tier, search, binOnly, category, includeRaw, and the UUID formats go unexplained. Most parameters are undocumented in both places.

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 (Fetch) and resource (SkyBlock Auctions) and enumerates the three operating modes (active pages, recently ended, API-key lookups), which map cleanly onto the mode enum. It also names the three lookup dimensions (auction, player, profile). The only soft spot is the trailing filler phrase 'Filters output for AI use', which adds no distinguishing power.

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 enumeration of modes implies which request shape to pick, but there is no explicit when-to-use/when-not guidance, no statement that lookup mode requires an API key or a concrete identifier, and no routing to any alternative tool. Usage 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that output is a compact/computed summary (useful vs. a raw dump) but says nothing about data freshness, caching, rate limits, or upstream API dependencies, which matters for an openWorld 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?

One dense sentence with no filler; the verb and the return payload are front-loaded. It is essentially a comma-separated content list, which is efficient but borders on enumeration rather than prioritizing the most decision-relevant output.

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

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

With no output schema, the description usefully enumerates the return sections, which is the main burden it must carry. However, for a 10-parameter tool it never explains how uuid/username/profileId/memberUuid interact, nor does it address data recency or that results are derived from upstream sources.

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 80%, so the baseline of 3 applies; the description references no parameter at all, including the significant `focus` list that shapes the audit. Two params (includeMayor, includeEconomy) are undocumented in both schema and description, so no compensation is provided.

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 ("Return a compact profile audit") and enumerates the concrete derived contents: computed levels, HOTM/HOTF trees, progression gaps, gear/loadout summaries, accessory analysis, and prioritized next actions. This implies a computed analysis rather than the raw data served by skyblock_profile, though no sibling is named explicitly.

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

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

There is no when-to-use guidance, no condition distinguishing it from skyblock_profile, skyblock_upgrade_advisor, or skyblock_networth, and no stated prerequisites (e.g., that a resolvable player/profile is needed). The audit framing implies usage but nothing is 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, openWorld, and non-destructive, so the safety profile is covered. The description adds that it returns prices, volumes, and spread signals, but says nothing about pagination, rate limits, or refresh freshness, leaving the lower-bar behavioral disclosure only partially met.

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

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

Two tight sentences, front-loaded with the core action, with no filler. It earns its place but is quite short given the parameter surface it must support.

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 6-parameter tool with 0% schema coverage and no output schema, the description omits all parameter semantics and only gestures at the return payload. An agent cannot tell how to constrain or shape results from the description alone.

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

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

Schema description coverage is 0% across 6 parameters (limit, search, sortBy, includeRaw, productIds, includeOrders), so the schema does the documentation work but with no descriptions at all. The description compensates by explaining none of the parameters, so an agent gets no guidance on sorting, filtering, or the raw/orders flags.

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 gives a specific verb (Fetch) and resource (Bazaar product prices, volumes, and spread signals), which is clear and concrete. It does not distinguish this from siblings like skyblock_auctions or skyblock_item, 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?

"Useful for money-making tips and crafting cost checks" implies the use context but gives no explicit when-to-use versus alternatives (e.g., auctions for player listings). Usage is suggested 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, openWorld, and non-destructive, so the safety profile is covered. The description adds two things annotations do not carry: the HYPIXEL_API_KEY requirement and the fact that absent participation is reported as unknown rather than as a failure. It still says nothing about pagination or result volume.

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

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

Three short sentences, front-loaded with the core action, with no filler. Efficient, though the 'stays unknown' clause reads slightly cryptic out of context.

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 five-parameter tool with no output schema and low schema description coverage, the description is thin. It omits how limit controls pagination and how uuid/username are expected to be supplied (both optional, zero required), which an agent needs in order 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 coverage is only 40%, so the description is expected to compensate. It loosely maps to eventId and includeCurrentEvent ('optionally match the current event goals') and identifies the player/uuid target, but leaves 'limit' and the uuid-vs-username relationship entirely unexplained.

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 ('Fetch a player's Bingo event history') plus the optional enrichment ('match the current event goals'). It is clearly distinguishable from the sibling set, which contains no other Bingo tool, though it does not name a sibling it must not be confused with.

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

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

Usage is only implied: an agent can infer this is the tool for Bingo data, but there is no explicit when-to-use, when-not, or alternative named. The note that 'missing participation stays unknown' hints at result conditions rather than invocation 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, openWorld, non-destructive, so the safety profile is covered. The description adds real behavioral value beyond that: Master Star items are not priced, unknown IDs yield found=false with suggestions, and star requests are effectively bounded by the dataset's max. It does not describe response shape or latency/caching behavior, keeping it short of 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?

Four tight sentences, front-loaded with the core computation, followed by the optional pricing mode and the edge-case behavior. No filler and every clause carries distinct 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 discloses key return semantics (found=false plus suggestions, clamped stars, coin estimate). What remains thin is the exact shape of a successful result and how quantity interacts with per-star costs, but the essentials for correct invocation are present.

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 itemId, toStar, fromStar, quantity, priceBasis, and priceWithBazaar are already documented with defaults, ranges, and an enum. The description reinforces the pricing concept (essence + materials, live Bazaar coin estimate) but adds no syntax or format detail the schema lacks, 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 (compute) and resource (essence/coin/material cost of essence-funded stars) scoped to a SkyBlock item ID, with authoritative per-star data. An agent can distinguish this cost-calculation tool from siblings like skyblock_upgrade_advisor, skyblock_networth, or skyblock_item without opening any schema.

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

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

Gives clear usage context: it prices optionally via live Bazaar, excludes Master Star items, and returns found=false with suggestions for non-upgradeable IDs. It stops short of explicitly naming a sibling alternative or stating when another cost/advice tool should be preferred instead.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description adds nothing behavioral beyond that: no note on auth requirements, rate limits, or what happens with ambiguous profile selection. No contradiction with annotations, but no added value either.

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

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

A single economical sentence with the resource list front-loaded and no filler. It is appropriately sized, though it could be slightly richer without becoming bloated.

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 7 parameters, no required fields, and no output schema, the description does list the three data categories returned, which partially compensates for the missing output schema. However, it does not explain selector behavior when no uuid/username is supplied or how multiple profiles are resolved, leaving the agent to infer resolution rules from the schema alone.

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

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

Schema description coverage is 100% across all 7 parameters, and each parameter carries a meaningful description (UUID format, username fallback, member vs. profile selectors, selectedOnly default). The description adds no parameter-level meaning 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?

The description names a specific verb (Fetch) plus the concrete resources it returns: garden plot, commission, and composter data, scoped to a SkyBlock profile. That is clear enough to distinguish it from siblings like skyblock_profiles or skyblock_inventory. It stops short of explicitly naming which sibling to prefer for related garden data, so 5 is not warranted.

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 use this tool versus alternatives (skyblock_profile, skyblock_inventory, etc.), nor any prerequisites or exclusions. Usage is only implied by the resource name in the 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 declare readOnly, idempotent, non-destructive, and open-world behavior, so safety needs no restating. The description adds a genuinely useful disclosure the annotations lack: the HYPIXEL_API_KEY authentication requirement. It says nothing about rate limits, caching, or the size/composition of the aggregated payload for a fan-out 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?

Two tight sentences, with the composite purpose front-loaded ahead of the prerequisite. Nothing is padded, though the auth sentence could have carried some parameter guidance instead of standing alone.

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 21-parameter, no-required-argument aggregation tool with no output schema, the description is far too thin. An agent gets no picture of output size (e.g. includeRawNbt, includeAllNbtData), how optional flags interact, or what the returned context actually contains, which is exactly what this tool's name promises.

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

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

With 21 parameters and only 62% schema description coverage, the description is the only place to compensate, and it adds almost nothing: no explanation of goals, uuid vs username vs profileId vs memberUuid, or how the include*/max* toggles shape the output. The mention of 'mayor and economy signals' loosely maps to includeMayor/includeEconomy but is not a substitute for parameter guidance.

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

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

States a specific verb ('Fetch') and a composite resource ('profile plus current mayor and economy signals') and frames the downstream goal (writing tailored progression advice). This is enough to distinguish it from plain data fetchers like skyblock_profile, though it never names the sibling 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?

The 'so an AI can write tailored SkyBlock progression advice' clause implies the intended use case (advice generation, not raw data retrieval), and it notes the HYPIXEL_API_KEY prerequisite. However, it gives no explicit guidance on when to prefer this over skyblock_profile, skyblock_profiles, or the related advisor tools, nor on how the many include*/max* flags should be chosen.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that output is decoded NBT and that filtering exists, but says nothing about how heavy the default payload is or what triggers the "very large output" flags the schema hints at. Adequate but thin beyond the annotations.

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

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

Two sentences, front-loaded with the verb and resource, zero filler. The section enumeration is long but earns its place by telling the agent what data is available without opening the 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 16 parameters, no required fields, and no output schema, the description is quite short. It never sketches the shape of the returned sections, item structure, or how the large-output opt-ins change the response, which is a real gap for a tool whose whole job is returning a complex payload.

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 81%, so the schema already explains nearly every parameter (uuid, username, sectionPaths, sectionTypes, includeRawNbt, etc.). The description only alludes to "filters" generically and adds no syntax, format, or interaction 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 a specific verb (fetch and decode) and resource (inventory-like NBT sections for one SkyBlock profile), and enumerates what those sections cover: wardrobe, armor, equipment, ender chest, backpacks, vault, bags. It is clearly distinguishable from decode_skyblock_nbt at a conceptual level, though it never names that sibling or skyblock_storage to draw the boundary explicitly.

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

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

"Use filters to keep output focused" is a mild operational tip but not real when-to-use guidance. Nothing tells the agent when this tool is preferable to skyblock_storage, decode_skyblock_nbt, or skyblock_profile, nor are any prerequisites (e.g. needing a profileId first) 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?

With readOnlyHint/idempotentHint/openWorldHint already covering the safety profile, the description adds meaningful non-annotation behavior: ambiguous searches degrade to a candidate list instead of guessing, the lowest-BIN price is contingent on an external source being configured (otherwise a plain auction-only note), and wiki retrieval can include official-wiki retirement information. These conditionals are exactly the kind of runtime conduct 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 front-loaded sentences that move from lookup to returned data to optional wiki context, with no filler. Slightly dense and occasionally clausal ('otherwise a clear auction-only note'), but every sentence carries operational information.

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

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

For a 7-parameter read tool with no output schema, the description adequately covers both the return payload and the main behavioral branches (bazaar vs BIN vs auction-only, candidate fallback, wiki augmentation). The main gap is that the ID-vs-search relationship and any mutual exclusivity are left 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 description coverage is 100%, so every parameter is already documented, making 3 the baseline. The description reinforces the conditional semantics of includeWiki and priceBasis ('used only for the lowest-BIN fallback') but adds little beyond what the schema text already states, and it never clarifies that itemId and search are alternative inputs or how maxCandidates interacts with resolution.

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 pairs a specific verb ('Look up') with a precise resource ('a single SkyBlock item by ID or name') and enumerates exactly what is returned: metadata (tier, category, stats, NPC price, museum/soulbound flags) plus a live value. It implicitly separates itself from siblings like skyblock_bazaar and skyblock_auctions by defining its output as bazaar data *or* a BIN fallback *or* an auction-only note, so an agent can distinguish it 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?

It gives clear conditional guidance: use includeWiki when wiki context is wanted, ambiguous searches return candidates rather than a guess, and the BIN price only exists when an external source is configured. It stops short of explicitly naming alternatives (e.g. 'use skyblock_wiki_search for pure wiki queries' or 'use skyblock_bazaar for pure market queries'), so no 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 declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description adds nothing behavioral beyond that - no auth requirements, no rate-limit or caching notes, no statement of what the value summary contains or how it is computed.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though arguably under-specified rather than deliberately concise.

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

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

With no output schema, the description should characterize the return payload, but 'museum donations and value summary' is vague for a tool with seven parameters and no required fields. Annotations carry the safety profile, so this is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so all seven parameters (uuid, username, profileId, memberUuid, profileName, selectedOnly, memberUsername) are already documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

States a specific verb (Fetch) and resource (museum donations and value summary) scoped to a SkyBlock profile member, which distinguishes it from siblings like skyblock_inventory or skyblock_networth. It does not name a sibling or draw an explicit boundary, but the resource is concrete enough for an agent to route correctly.

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

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

The description gives no when-to-use or when-not-to-use guidance and never mentions alternatives, despite siblings such as skyblock_networth and skyblock_profile that overlap in the 'value/profile data' space. Usage is only implied by the resource name.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds real behavioral context beyond that: pricing comes from live Bazaar data with an optional external lowest-BIN source, modifiers are only counted if 'supported', and the response includes pricing coverage - useful disclosure of dependencies and known gaps.

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

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

Two dense sentences with no filler; the compute-and-price mechanics are front-loaded before the return-value summary. Slightly packed - the second sentence is a long comma list - but every clause carries information.

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

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

With no output schema, the description responsibly enumerates the return payload (total, per-section breakdown, top items, modifier breakdown, pricing coverage). The one gap is that with 13 optional parameters and four different player/profile identifiers, it gives no hint about which identifier combination to prefer.

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 85%, so the schema already documents nearly every parameter, making 3 the baseline. The description loosely maps to a few flags (sacks, modifiers, auction pricing) but adds no format or interaction detail beyond the schema, and gives no guidance on choosing among the four identity parameters.

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

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

States a specific verb ('Estimate') plus a specific resource ('a profile's net worth') and enumerates the value sources (liquid coins, decoded inventory/storage, sacks, modifiers). This clearly differentiates it from the component-level siblings like skyblock_inventory, skyblock_storage, and skyblock_bazaar, which it aggregates.

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 purpose - an agent can infer it should be used when a user asks for total value rather than raw holdings - but there is no explicit when-to-use/when-not-to-use guidance and no alternative named (e.g. 'use skyblock_inventory if you only need raw items'). Nothing misleading, just unstated.

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 readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered without the description. The description adds only that output is 'compact AI-readable' and that decoded inventories are optional; the genuinely important cost traits (very large output for raw NBT/member/profile flags, default decodeInventories=true) live in the schema, not here.

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

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

A single dense sentence, front-loaded with verb and resource and then the payload contents, with no filler or repetition. It is slightly over-packed with a long enumeration, but every clause carries information.

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

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

For a 20-parameter tool with no required arguments and no output schema, the description correctly enumerates the returned context and notes that inventories are optional, so an agent knows roughly what comes back. It stops short of explaining identifier selection, the selectedOnly default behavior, or the output-size implications of the raw flags, which is what an agent most needs before calling this.

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 85%, so the schema already explains nearly every parameter, including defaults, bounds, and filter semantics. The description contributes only the high-level list of returned sections and does not clarify precedence among uuid/username/profileId/profileName or how selectedOnly interacts with them. 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 concrete verb and resource ('Fetch one SkyBlock profile') and enumerates the returned member sections (skills, slayers, dungeons, pets, collections, currencies, accessories, inventories), which meaningfully separates it from the plural list tool skyblock_profiles and from skyblock_inventory. It never names a sibling explicitly, so the differentiation is inferential 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?

There is no when-to-use or when-not-to-use guidance, and no routing to alternatives such as skyblock_profiles, skyblock_inventory, or skyblock_storage, all of which overlap in scope. With 20 optional parameters and no required identifier, the description gives no help on which identifier combination to pick or when a lighter sibling is preferable.

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, open-world behavior, so the safety profile is covered. The description adds genuinely useful context beyond that: an auth prerequisite (HYPIXEL_API_KEY) and the fact that results are filtered by the player's API privacy settings, which can silently reduce output. It does not describe pagination or output shape, but with no output schema that is a minor gap.

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

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

Two tight sentences, no filler. The core purpose leads and the operational constraints follow, so an agent gets the essential facts in the first clause.

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

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

For a read-only list tool with no output schema, the description covers purpose, auth, and privacy caveats, and the schema fully documents inputs. It could be stronger by mentioning that profiles are returned compactly vs. the detail tool, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is 100% – uuid, username, and includeRaw are each documented in the schema, including the 'use this when the user gives a name' routing hint. The description adds nothing about parameter behavior, 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 ('List a player's SkyBlock profiles') plus scope ('compact member metadata'), which cleanly separates it from the singular skyblock_profile sibling. It stops short of explicitly naming that sibling or clarifying the profile-vs-detail split, so it falls just below the top tier.

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

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

The description gives preconditions (requires HYPIXEL_API_KEY, respects privacy settings) but never says when to pick this over skyblock_profile, resolve_player, or skyblock_audit. Usage is only implied by the resource name.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds that these are public resources spanning several kinds, but says nothing about rate limits, caching, or the shape/size of results for a multi-kind fetch.

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

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

Two tight sentences, front-loaded with the verb and resource, no filler. Brevity is achieved without padding, though it is arguably too terse for a 7-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?

With 7 params, 43% schema coverage, no output schema, and six distinct resource kinds behind one enum, the description leaves too much unexplained: how filtering interacts with kind, what each kind returns, and the role of includeRaw. It is under-specified for the tool's complexity.

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

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

Schema description coverage is only 43% and there are 7 parameters. The description gestures at filtering but never explains search, limit, includeRaw, or which filters apply to which kind beyond the hardcoded schema notes, so it does not compensate for the coverage gap.

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 (fetch) and resource (public SkyBlock resources), and enumerates the supported kinds: items, skills, collections, election, bingo, news. It does not, however, distinguish itself from siblings like skyblock_item or skyblock_bingo that appear to overlap on the same resources.

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 only usage-adjacent sentence is 'Supports filtering for item and resource searches,' which describes a capability rather than when to choose this tool. With siblings such as skyblock_item, skyblock_bingo, and skyblock_wiki_search present, no routing guidance is offered.

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, openWorld, and non-destructive, so the safety profile is covered. The description adds real behavioral context by saying items are decoded and merged across locations and that output is grouped counts plus sack totals. However, it omits the cost/latency character of a full NBT decode, auth needs, or that large-section output is a risk, leaving moderate gaps.

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

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

Two densely packed sentences with the actor/action front-loaded and the return shape last. No filler, though the container enumeration could be tightened since sectionTypes already lists these values.

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 helpfully sketches the return shape (grouped counts, sack totals, optional per-section detail), which is genuinely needed. Against a 17-parameter surface with zero required params and no enums, though, it gives no guidance on the uuid/username/profileId interplay or on scoping the potentially large decode.

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 76%, above the baseline threshold, so the schema carries most parameter meaning; the description adds essentially none. Several tuning parameters (itemLimit, maxSections, includeItemDetails, maxItemsPerSection) are undocumented in both schema and description, so this is adequate but not compensatory.

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?

Names a specific action (decode and merge items) and enumerates the resources involved: backpacks, ender chest, personal vault, sacks, bags, and inventory. An agent can tell this is a storage-aggregation tool. It does not, however, distinguish itself from the sibling skyblock_inventory, whose scope overlaps heavily with this enumeration.

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

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

The description states capability but gives no when-to-use guidance, prerequisites, or alternatives. It never says when to prefer skyblock_storage over skyblock_inventory or skyblock_networth, which is the central routing decision for this family of tools.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), but the description adds real behavioral context: per-upgrade confidence and caveats, budget-aware filtering, and an explicit honesty contract that unsupported sources are named rather than fabricated. It does not discuss failure modes or latency, but the gaps-instead-of-numbers disclosure is a meaningful addition.

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?

Content is front-loaded with the core action ('Rank the gear and accessory upgrades') and every clause carries information, including the return shape and the honesty constraint. It is dense and comma-heavy with one very long sentence, but no sentence is wasted.

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

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

With no output schema, the description carries the return-value burden and does so well: ranked action list, per-upgrade confidence and caveats, and a coverage block listing unsupported sources. Combined with 91% parameter coverage and 11 schema-documented params, an agent has everything needed to invoke 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 91%, so the baseline is 3. The description still adds value by explaining what the sources enum means operationally (star and accessory priced; reforge/enchant/hotm/pet reported unsupported) and by tying budgetCoins/priceBasis to the 'honestly costed' gating condition, which the schema does not convey on its own.

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 ('Rank the gear and accessory upgrades available to a profile') and narrows the scope precisely to two upgrade classes: essence-star costs on equipped gear and next-tier accessory upgrades. An agent can distinguish this from sibling tools like skyblock_essence_costs (raw cost data) or skyblock_networth 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 clearly frames when the tool is applicable: only sources that can be 'honestly costed today,' with accessory prices requiring a configured lowest-BIN source. It does not explicitly name alternatives (e.g., use skyblock_essence_costs for raw star costs) or state when-not-to-use, so routing guidance is implied rather than 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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description's added value is the provenance behavior: a retired official source that returns explicit availability information by default, and replacement content that is explicitly labeled non-official. That is meaningful disclosure an agent could not infer from the schema or annotations.

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

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

Three compact sentences, front-loaded with the core action and returning the highest-value provenance caveat alongside it. Slight redundancy between 'configured' and 'non-official' wording keeps it from a 5.

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

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

With no output schema, the description does describe what comes back (revision time, cleaned sections, availability status, non-official labeling), which is the essential return-value burden. It is nearly complete for a read tool whose annotations already declare the safety profile.

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 75% (title, search, includeRaw are documented; maxSectionChars is not), so the schema carries most of the semantic load and the baseline of 3 applies. The description adds nothing about parameters, and notably never connects 'cleaned sections' to maxSectionChars, leaving the one undocumented param unexplained.

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 page from the configured MediaWiki source) and even sketches the return shape (revision time, cleaned sections). It implicitly separates itself from the sibling wiki-search tool by being a page fetch, but never names that sibling 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?

There is no statement of when to use this tool versus skyblock_wiki_search or any other sibling, and no exclusions. The only usage-adjacent note (retired official wiki returns availability info; replacement content is labeled non-official) describes content provenance rather than selection 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/openWorld/idempotent, so the bar is lower. The description still adds meaningful behavior: the env-var dependency and fallback to retirement content, plus the caveat that results identify their source and are not assumed official. It omits pagination or result-shape detail, but the added context is substantive.

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

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

Three tight sentences, front-loaded with the core action and followed by the two genuinely decision-relevant caveats. Nothing is padding.

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 partially covers returns ('results identify their source'), and it handles the important edge case of missing configuration. Only the undocumented limit parameter and return shape keep it short of full completeness.

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

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

Schema coverage is 50% – the 'search' query is documented in the schema while 'limit' is not. The description adds no parameter meaning at all (no query syntax, no result-count behavior), so it fails to compensate for the coverage gap.

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 (Search) and resource (a configured MediaWiki source for SkyBlock knowledge), which clearly separates it from siblings like skyblock_wiki_page or skyblock_resource. It does not explicitly name the sibling it differs from, but the 'search a source' framing is distinctive enough.

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 real usage context: it explains the official wiki retirement and that without SKYBLOCK_WIKI_BASE the tool returns retirement information rather than results. However, it never states when to choose this over skyblock_wiki_page or other knowledge siblings, so the routing decision 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.