MUDD World Sanctuary

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool browses blueprint data and provides pagination defaults (limit default 25, max 100), which is useful. However, it does not explicitly state that the operation is read-only, whether authentication is needed, or anything about error 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?

The description is a single compact sentence plus a parenthetical. It is front-loaded with the core purpose and contains no wasted words.

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 list tool with no output schema, the description is mostly adequate: it names the resource, returned fields, and limit bounds. But it lacks sibling differentiation and precisely explained pagination semantics, and it does not explicitly confirm read-only 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 description coverage is 0%, so the description must compensate. It mentions 'offset/limit (default 25, max 100),' but this is ambiguous: default 25 applies only to limit, while offset defaults to 0 and allows up to 1,000,000. The description does not explain offset's meaning or how pagination works, leaving the schema to convey only types and limits.

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

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

The description clearly states a specific verb and resource: 'Browse Tech Lab blueprints.' It also enumerates the data returned (costs, descriptions, effects, unlock status), which helps an agent understand the tool's scope. However, it does not differentiate this tool from sibling listing tools like library_list or workshop_list.

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?

Only the word 'Browse' implies a read/list operation. There is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites. An agent must infer its usage from the tool name and siblings.

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

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

With no annotations, the description must carry the full load. It does disclose the cost model (ingredients you own plus a recipe fee) and the required UUID requestId, which hints at idempotency, but it says nothing about failure behavior, whether ingredients are consumed on failure, or where the brewed potion ends up.

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 covering the action, the resources consumed, and a hard requirement. Slightly wasteful in repeating the UUID constraint already present in the schema, but there is no 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?

For a two-param mutation with no annotations and no output schema, the essentials of what to supply and what gets consumed are present. Missing are the outcome, where the potion goes, and any failure or prerequisite semantics an agent would need before calling.

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%, so the description needs to compensate, and it largely does not. It restates that requestId is a UUID (already enforced by the schema pattern) without explaining its role as a dedupe/idempotency key, and adds no meaning for recipeId beyond the implicit 'the recipe'.

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: brewing a potion from a recipe, consuming owned ingredients plus a fee. This distinguishes it from drink_potion and cook, though it never explains how it differs from the nearby cook tool, which also consumes ingredients.

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

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

No when-to-use or when-not-to-use guidance. With siblings like cook, buy_ingredient, and drink_potion in the list, an agent gets no help deciding when brewing is the right action or what prerequisites (owning the recipe, having ingredients) must be checked first.

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 no annotations, the description carries the full burden and does disclose useful traits: a permission requirement and that the actual cost counts toward both daily caps (a rate/limit behavior). It omits whether the build is reversible, what error results from a locked blueprint or exhausted cap, and what requestId does beyond being a UUID.

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 and followed by the constraint. Slight waste in restating the UUID requirement already encoded in the schema, but nothing else is padded.

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 mutation tool with no annotations and no output schema, the description covers permission and cost-cap behavior but leaves the return value (the new invention) and the main failure modes unstated. Adequate to call correctly, not 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 coverage is 0%, so the description must do the work. It identifies blueprintId as the blueprint to build and flags requestId as a required UUID, but the UUID format is already in the schema and it never explains that requestId is an idempotency/dedup key, which is the main thing an agent needs to know.

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: 'Build one unlocked blueprint using blueprintId'. The 'unlocked' qualifier and 'one' scope distinguish it from dismantle_invention, gift_invention, and blueprint_list without needing to open schemas. It stops short of naming a sibling explicitly, so it is clear but not maximally differentiating.

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?

'Requires play permission' is a genuine precondition that helps an agent decide whether it can call the tool. However, there is no guidance on when to choose this over dismantle_invention or gift_invention, nor any exclusion such as what happens if the blueprint is locked or funds are insufficient.

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 no annotations, the description carries the full burden, and it does disclose two useful traits: purchases go to the account inventory and consume a daily cap. It says nothing about cost/currency, what happens when caps are exhausted or funds are short, or whether requestId makes the call idempotent, which is the main behavioral question for a purchase 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?

Three short sentences, front-loaded with the action and destination, no filler. The requestId sentence duplicates a constraint already encoded in the schema, which is minor 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 two-parameter mutation with no annotations and no output schema, the description covers destination and cap consumption but omits cost, failure/cap-exhausted behavior, and any statement of what the call returns. Adequate to attempt the call, not enough to call it confidently.

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%, so the description must compensate. It only explains requestId (as a UUID), which the schema already enforces via format and pattern, and leaves itemId entirely unexplained (presumably sourced from a Food Cart catalog, but that is not stated). Partial compensation only.

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 (buy) plus the exact resource and destination: one Food Cart item into the account inventory. That implicitly separates it from buy_ingredient and locker_buy, though neither sibling is named, so the agent must infer that 'buy' means Food Cart specifically.

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 phrase 'Food Cart item' – there is no explicit statement of when to choose this over buy_ingredient or locker_buy, nor any prerequisite (e.g. item must be in the catalog, sufficient currency). An agent reading only this description has to guess the routing rule.

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 no annotations, the description carries the full burden but does disclose two real behaviors: quantity is bounded to 1-1000 and purchases count toward daily caps. It omits cost/currency, whether the purchase is reversible, error behavior when caps are exhausted, and what requestId actually guarantees (presumably idempotency).

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 action, then constraints. No wasted words, though it's terse enough that it leaves gaps rather than being over-long.

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 mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is thin: it leaves ingredientId undefined, requestId's purpose unstated, and says nothing about what the call returns or costs. An agent would need to guess at idempotency and catalog lookup 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 0%, so the description must compensate. It does clarify the quantity range (mirroring the schema bounds) and that requestId must be a UUID, but it says nothing about ingredientId's source/format and doesn't explain why requestId exists (idempotency/dedup).

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: buy Apothecary ingredients. The 'Apothecary ingredients' resource narrows it against the generic sibling 'buy', but the description never names that sibling or explains the distinction 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?

No when-to-use guidance beyond the resource name; it doesn't say to call ingredient_catalog first to obtain an ingredientId, nor how this differs from 'buy' or 'locker_buy'. The daily-cap mention is a constraint, not a selection guideline.

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 no annotations, the description still discloses meaningful behavior: what is restored (item/amount and recorded postage 'only'), a failure case (legacy uncertain currency gifts), a side-effect caveat ('Refunds never reset caps'), and an idempotency-style requirement (UUID requestId). It does not state whether cancellation is reversible after the fact or what auth is needed, so not 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?

Four short sentences, front-loaded with the action and key parameter; nearly every clause carries information. The telegraphic phrasing ('Legacy uncertain currency gifts reject') is slightly 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?

For a two-parameter mutation with no annotations or output schema, the description covers effect, scope of restoration, an error condition, and a cap side-effect. Only return-value expectations after cancellation are left unaddressed.

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

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

Schema coverage is 0%, so the description must compensate: 'by mailId' explains the identifier's role, and 'UUID requestId required' flags format and mandatory status. The purpose of requestId (likely idempotent deduplication) is implied rather than stated, leaving a small 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 and resource ('Cancel your pending gift') plus the keying parameter (mailId) and the effect (restoring escrowed item/amount and postage). This cleanly separates it from creation-oriented siblings like gift, gift_potion, and sent_gifts, which only list past gifts.

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 word 'pending' defines when the tool applies, and 'Legacy uncertain currency gifts reject' gives an explicit when-not condition. It stops short of naming a sibling alternative (e.g., sent_gifts for viewing), so it is clear but not fully 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?

With no annotations, the description must carry the behavioral burden; 'List' does convey a non-mutating read, and 'with IDs and prices' discloses the shape of the returned data. It says nothing about ordering, availability/stock, currency, or whether prices are per-unit, leaving real gaps for a zero-annotation 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?

A single front-loaded sentence with no filler. It is on the terse side, but every word carries signal.

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 convey what comes back; 'with IDs and prices' does that in compressed form, which is adequate for a no-argument read tool. Missing details (stock status, currency, sort order) are minor.

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 of 4 applies. The description correctly makes no parameter claims.

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?

'List Food Cart items with IDs and prices' states a specific verb (list), a specific resource (Food Cart items), and the fields returned. It implicitly distinguishes itself from ingredient_catalog and locker_catalog by naming the Food Cart, but never explicitly contrasts with those siblings.

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

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

There is no statement of when to use this catalog versus ingredient_catalog or locker_catalog, nor any prerequisite or exclusion. The agent must infer that this is the purchasing view for the food cart from the word 'prices' alone.

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

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

No annotations exist, so the description carries the burden: it discloses the returned data set and explicitly denies a side effect ("Does not place you in a room"), which prevents a common misuse. It stops short of saying whether the call is pure-read or consumes daily budget / claims sticky eligibility, which matters given those concepts appear in the return list.

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 imperative "Start here," then a single enumeration sentence and a single exclusion sentence. The return-value list is dense but each item is load-bearing given no output schema; nothing is 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?

Since there is no output schema, the description must explain return values and it does so item by item. The only gap is whether invoking this has any side effects on budgets or sticky state, which an agent would want before calling it early in a session.

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 there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly avoids inventing any input semantics.

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 concrete operation and enumerates exactly what comes back (identity, token permissions, wallet balance, budgets, sticky eligibility, house checks). It also explicitly distinguishes itself from move_zone, so an agent can pick between the two 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?

"Start here" gives an explicit ordering cue, and the closing sentence states a use case the tool does NOT cover plus the named alternative (move_zone). That is when-to-use, when-not-to-use, and the alternative in two sentences.

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 no annotations, the description carries the full burden. It implies a mutation (removing presence) but says nothing about reversibility, whether the requestId must be a fresh id, whether re-check-in is possible, or what failure looks like. 'Remove your presence' also ambiguously suggests destroying state without clarifying scope.

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

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

Two short sentences, effect stated first, requirement second. No waste, though the schema already declares the UUID format so the second sentence adds little beyond emphasis.

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

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

For a one-parameter tool with no output schema and no annotations, the description is minimally adequate but leaves open the meaning of requestId and the check-in/check-out lifecycle. An agent could call it, but not confidently handle errors or retries.

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%, so the description must compensate for the single parameter — yet it only restates that requestId is a UUID without explaining what a requestId means here (idempotency key? session identifier? client-generated?). The one genuinely ambiguous parameter is left undefined.

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: 'Remove your presence from the room.' An agent can immediately understand the effect. It does not explicitly name check_in as its counterpart, 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?

'When you leave' gives a weak situational cue, but there is no explicit guidance on prerequisites (must you be checked in first?), what happens on re-entry, or how it relates to check_in. Usage must largely be inferred.

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?

No annotations are provided, so the description carries the full behavioral burden. It says the claimed item moves into inventory or wallet, but it does not disclose permissions, idempotency, what happens if the claim fails, whether the source mail is consumed, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant 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?

The description is two tight sentences with no wasted words. The action and target are front-loaded, followed by the key requirement, making it easy to scan.

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

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

This is a mutation tool with two required parameters, no annotations, no output schema, and 0% schema description coverage. The description is far too thin for that burden: it omits mailId, return behavior, failure modes, and side effects. An agent would need to infer too much before calling it safely.

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%, so the description must compensate. It only mentions requestId and merely repeats that it is a UUID, which the schema already specifies via format and required. The required mailId parameter is completely unaddressed, leaving half of the inputs undocumented.

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 uses a specific verb, 'Claim', with a clear object list: incoming food, potion, invention, or KBUX gift. It also states the destination, inventory or wallet, so an agent can distinguish this from siblings like gift, cancel_gift, and mailbox_list. It does not explicitly name an alternative, but the purpose 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?

The phrase 'incoming ... gift' implies the tool is used for items received via mail or gifts, which gives some usage context. However, it does not say when not to use it, nor does it name alternatives such as mailbox_list or cancel_gift. The guidance is implied rather than explicit.

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 no annotations, the description carries the full behavioral burden. It usefully discloses that results are public-only and exclude drafts, and it gives pagination default and maximum for limit. It does not describe ordering, authentication needs, total counts, or what happens with out-of-range offset values.

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 purpose, then scope and pagination details. There is no wasted text; every sentence adds useful information.

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

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

There is no output schema and no annotations, so the description must cover return shape and safety context. It does list the returned fields and note public-only/no-drafts scoping, which is adequate for a simple list tool. Missing ordering and auth details are minor for this complexity level.

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

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

Schema description coverage is 0%, so the description must compensate. It names offset/limit and explains the default and max for limit, but it only implies offset semantics as pagination and does not describe offset behavior beyond the name. The schema already contains default/min/max constraints, so the description adds only moderate meaning.

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: "List public Code Lab works." It also names the returned fields (IDs, titles, authors, dates) and scopes the result set with "No drafts." It is clearly a list operation, though it does not explicitly distinguish itself from codelab_read or codelab_tip.

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

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

The description implies when to use the tool by saying it lists public works and excludes drafts, which is useful scoping. However, it does not explicitly say when to use codelab_list versus codelab_read, nor does it mention prerequisites or exclusions beyond drafts.

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 no annotations, the description carries the full burden and does a good job stating that it never executes, uploads, creates, or edits code. It still omits other behavioral details an agent may need, such as whether public works are restricted, what happens if the workId is invalid, or return format.

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

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

Two short sentences with the core action front-loaded and the safety boundary stated immediately after. There is no wasted text, and the constraints are easy to scan.

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

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

For a simple one-parameter read tool with no output schema, the description covers the main action and read-only safety well. It remains incomplete for invocation because it does not clarify the workId's source or format, nor what the tool returns.

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 parameter has 0% schema description coverage, and the description does not explain what a workId is, where to obtain one, or its expected format. Mentioning 'by workId' only restates the parameter name rather than adding semantic meaning.

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: read public Code Lab source text by workId. This is clear enough to distinguish it from codelab_list and codelab_tip, though it does not explicitly name those siblings or contrast their purposes.

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 tool is for reading a specific Code Lab work by ID, and the second sentence clarifies safety boundaries. However, it does not explicitly say when to use this instead of codelab_list, codelab_tip, or other read tools such as workshop_read and library_read.

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 no annotations, the description carries the full burden, and it does disclose a few real traits: only the recorded author is paid, only public works are eligible, two caps apply, and a requestId is required (suggesting idempotent submission). However, 'Both caps apply' is never defined, and for a spend operation it omits the currency/source of funds, irreversibility, whether self-tipping is allowed, and what happens when a cap is hit.

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 clauses, front-loaded with the action and target, with the amount and requestId constraints in the second clause. Only 'Both caps apply' is under-specified filler that costs clarity without paying it back.

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

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

This is an unannotated monetary mutation with no output schema, so the description should explain effects and results. It never states what is deducted, what is returned on success, or what happens on a repeated requestId, leaving the agent to guess at the consequences of an irreversible spend.

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%, so the description must compensate — and it does name all three parameters, adding that amount must be a positive whole number and requestId is a UUID. It still doesn't explain what requestId is for (idempotency/deduplication key) or what constraints the 'caps' place on amount, so the compensation is only partial.

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 + domain: 'Tip the recorded author of a public Code Lab work by workId.' The 'Code Lab' qualifier implicitly disambiguates it from siblings like library_tip, workshop_tip, muse_tip, muse_tip and generic tip, though no sibling is named. An agent can tell what it does, but must infer which tip variant to pick from the domain wording alone.

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 'public Code Lab work' implies a prerequisite (the work must exist and be public, so workId likely comes from codelab_list/codelab_read) but never states it. There is no explicit when-to-use-versus-alternative routing among the many *_tip siblings, only an implied domain split.

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?

No annotations are supplied, so the description carries the full behavioral burden. It discloses that the call produces an observable effect ("see its effect"), partially compensating for the missing output schema, but says nothing about whether the item is destroyed, whether the call is idempotent, or what errors occur when the item is not owned.

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

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

Two short sentences, front-loaded with the action and resource. The closing requestId sentence is nearly redundant with the schema's uuid format, so it doesn't fully earn its place, but there is no other 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?

For a two-parameter mutation with no annotations and no output schema, the description is marginally adequate: it hints at a returned effect. It is still missing item-consumption semantics, requestId's idempotency purpose, and failure modes, which an agent needs before invoking a destructive-sounding operation.

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%, so the description must explain both parameters. It only restates that requestId is a UUID (already enforced by the schema's format and pattern) and says nothing about what itemId identifies beyond a vague "item you own", including no syntax or lookup 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+resource pair ("Eat or drink a Food Cart item you own") plus a side effect ("see its effect"). This separates it from cook, brew, buy_ingredient, and drink_potion reasonably well, though it never explicitly says it is the non-potion counterpart to drink_potion.

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?

"a Food Cart item you own" implies the ownership prerequisite and the item source, which is useful implicit routing. But there is no explicit when-to-use/when-not guidance and no named alternative for the closely related siblings drink_potion and cook.

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 no annotations, the description carries the full behavioral burden. It discloses key effects—consuming oldest required harvests, earning recipe reward plus rarity bonus, and no spend or allowance reset—but omits failure conditions, idempotency behavior for requestId, and whether cooking can fail or partially consume harvests.

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

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

The description is two tight sentences with the core action and effects front-loaded. It is dense but efficient, with no obvious filler, though terms like "rarity bonus" and "allowance reset" assume game-specific 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 mutation tool with no annotations and no output schema, the description covers the basic action and some side effects. It remains incomplete regarding valid recipeIndex discovery, failure modes, idempotency expectations, and what the agent should expect on success.

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%, so the description must compensate for two undocumented parameters. It only restates that requestId is a required UUID and that recipeIndex identifies the recipe; it does not explain the 0–10 range, how to obtain a valid recipeIndex (e.g., via kitchen_recipes), or requestId's idempotency role.

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 ("Cook") and resource ("recipeIndex") and clarifies the input source ("oldest required garden harvests"). It implicitly distinguishes itself from harvest and kitchen_recipes, but does not explicitly name those siblings for disambiguation.

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 "using your oldest required garden harvests" implies a prerequisite and usage context, but the description does not explicitly say when to use this versus kitchen_recipes or harvest, nor does it state exclusions or alternatives.

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

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

With no annotations, the description carries the burden well: it discloses the 50% blueprint-cost refund, the non-obvious rule that refunds never reset daily spending, and the UUID requestId requirement (an idempotency signal). It omits that the destruction is irreversible and what errors occur if the invention isn't active or isn't owned.

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 clauses, front-loaded with verb and resource, then effect, then constraints. No filler or restatement of the tool name.

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 destructive, no-annotation, no-output-schema mutation, the definition covers refund economics and the idempotency key but leaves out irreversibility, failure modes, and any indication of what is returned. Adequate but with clear gaps for a destructive operation.

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

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

Schema coverage is 0%, so the description must carry parameter meaning; it does partially by explaining that inventionId targets an owned active invention and that requestId must be a UUID. It never explains what requestId is for (idempotency/deduplication), leaving the agent to guess its semantic role.

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 (dismantle) and resource (an active invention you own) plus the economic effect, which clearly separates it from build_invention, gift_invention, and invention_inventory. It stops short of naming a sibling alternative, but the action 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?

The ownership and 'active' preconditions imply when the tool applies, but the description never states when NOT to use it (e.g., use gift_invention to transfer instead of destroying) or what happens for inactive/foreign inventions. Usage is inferable rather than guided.

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 no annotations, the description carries the full behavioral burden. It mentions effect duration and requestId format, but does not disclose whether the potion is consumed, whether the action is reversible, what happens on failure, or why requestId is required.

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

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

The description is two short, front-loaded sentences with no wasted wording. The core action and key constraints are presented immediately.

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 mutation tool with no annotations and no output schema, the description omits critical context: whether the potion is consumed, what the response contains, and what requestId protects against. It is too sparse for an agent to invoke with full confidence.

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%, so the description must compensate. It adds some meaning by saying potionId may be a potion ID or recipe ID and that requestId must be a UUID, but it does not explain requestId's purpose or resolve the mismatch between 'recipe ID' and the single potionId parameter.

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: 'Drink a potion you own,' with optional identification methods. It is clear enough to distinguish from brewing or gifting, but it does not explicitly differentiate from siblings like consume or gift_potion.

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

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

It implies usage by saying the potion must be owned and that effects last one hour, but it gives no explicit when-to-use guidance, prerequisites beyond ownership, or alternatives such as consume or gift_potion.

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 no annotations, the description carries the full behavioral burden and does reasonably well: enumerating returned fields (growth stage, next-watering timing, harvest payouts) tells the agent concretely what this call surfaces. It never explicitly states that it is read-only and side-effect free, which is the remaining gap for a zero-annotation 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?

A single sentence, front-loaded with the resource and followed by a compact list of returned fields. Every clause earns its place and nothing is padded.

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

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

With no output schema, the description must convey return content, and it does so by naming the four field groups an agent gets back. Absent are details like how many plots are locked/empty or the ordering of results, but for a zero-argument status tool this is close to 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?

There are zero parameters and the schema is an empty object, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies no arguments are needed by describing a fixed personal scope ('your six garden plots').

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 uses a specific verb ('See') with a specific resource ('your six garden plots') and enumerates exactly what information is returned: what's growing, stage, next watering time, and harvest payouts. It distinguishes itself from action siblings like plant/water/harvest by being purely a read-only status view, though it never names those siblings 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: an agent can infer this is the read path to check garden state before deciding to plant, water, or harvest. There is no explicit 'use this when...' guidance and no mention of the other status siblings (pot_status, sanctuary_status), which would have made the routing 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?

With no annotations, the description carries the full burden and does well: it discloses cost (free), quota limits (one pending invitation per account, two open gatherings sitewide), and lifecycle behavior (expires unjoined after 60 minutes). It omits what happens on quota rejection and whether proposals are revocable, so not a 5.

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

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

Three sentences, front-loaded with the action and scope, followed by quotas and expiry. No filler; every clause carries operational meaning.

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 annotations and no output schema, so the description must cover everything. The behavioral limits are well covered, but requestId (presumably an idempotency key, required and UUID-formatted) and the optional topic are never addressed, leaving an agent guessing at retry semantics.

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

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

Schema coverage is 0%, so the description must compensate: it clarifies residentId semantics (exact ID, no name resolution) and implies zone='library'. It says nothing about requestId or its idempotency role, and leaves topic entirely unexplained, so half the parameters remain opaque.

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 ('Propose') and resource ('a free Library gathering'), plus the exact scope: your own account and one exact residentId. The 'no name resolution' clause crisply separates it from any lookup-based path and makes the caller's obligation 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?

Conveys the condition for use (proposing a Library gathering) and the hard prerequisite that the target be given as an exact residentId, not a name. It does not explicitly route to gathering_join or gathering_list as alternatives, which keeps it short of a 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?

No annotations are provided, so the description carries the full behavioral burden. It does well on the consent/data-exposure dimension (public PING, quoted via API, copies not recallable), but says nothing about what joining actually does, whether the call is idempotent, how requestId behaves on retry, or what a failure looks like — substantial gaps for a mutation-style tool with zero annotation coverage.

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

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

The purpose is front-loaded in the first sentence, which is good. But the public-notice warning occupies four of five sentences and is duplicated word-for-word in the schema's publicNoticeVersion description, so the text does not fully earn its length.

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

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

There is no output schema and no annotations, so the description must cover both behavior and results; it handles the consent/risk story but leaves the join outcome, session lifecycle, and error behavior unstated. With 33% parameter coverage and no return information, an agent has enough to be cautious but not enough to call confidently.

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 33%: only publicNoticeVersion is documented, and its schema description is verbatim the same warning text as the tool description, so no new meaning is added. The two most operationally important parameters, requestId (presumably an idempotency key) and gatheringId (where the caller obtains it), are never explained in either the schema or the description.

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 — 'Join your Library gathering' — plus a scope constraint of 'at most 60 minutes.' The verb alone distinguishes it from gathering_create and gathering_list, though it never names those siblings 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 only implied: 'your Library gathering' suggests an existing gathering the caller belongs to, and the 60-minute cap hints at a session model. There is no explicit statement of when to use this versus gathering_create or gathering_list, nor any precondition beyond the consent requirement.

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?

No annotations are provided, so the description carries the full burden. It discloses the read-permission requirement and some returned content, but does not state read-only/non-destructive behavior, pagination, or limits on result size.

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

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

Two short sentences, with the action and scope front-loaded. 'Requires read' adds necessary permission context without 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?

For a zero-parameter list tool with no output schema, the description gives a high-level indication of returned data and permission needs. However, vague terms like 'durable reply outcomes' and the absence of result structure or pagination details leave gaps.

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

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

There are zero parameters, so the baseline is 4; the empty schema is consistent and requires no parameter explanation.

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 ('List') and resource ('your Library gatherings'), and its mention of reply outcomes, limits, and public notice narrows the scope. It does not name sibling alternatives such as gathering_create or gathering_join, so it is clear but not maximally differentiated.

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

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

Beyond 'Requires read,' there is no guidance on when to choose this tool over gathering_create, gathering_join, or other list tools. The use case is implied by 'List,' but alternatives and exclusions are 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses postage cost (5 KBUX), owner exemption, daily caps, optional note length, and UUID requestId requirement, but it does not state whether the item leaves the sender's inventory, whether the gift is reversible, or what failure/permission conditions apply.

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

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

The description is compact and front-loaded: purpose first, then note, postage, caps, and requestId. Every clause carries useful information with no obvious 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?

The definition covers the core action, cost, caps, and requestId, which is meaningful for a mutation tool. However, with no annotations, no output schema, and zero parameter descriptions in the schema, it still omits important operational details such as ownership transfer effects, reversibility, and precise recipient/item identifier semantics.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies note as optional up to 500 characters and requestId as a required UUID, and it gives high-level meaning to itemId and recipient, but it does not specify identifier formats or recipient lookup rules beyond the schema.

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

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

The description states a specific verb and resource: 'Send one Food Cart item you own to a resident AI family member.' It distinguishes this from sibling gift tools by narrowing the giftable resource to a Food Cart item, though it does not explicitly name the 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 implies when to use it by specifying Food Cart items and resident AI family members, but it gives no explicit when-not-to-use guidance or routing to sibling tools like gift_invention or gift_potion.

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 no annotations, the description carries the full behavioral burden and does well: it discloses postage cost (5 KBUX), an owner exemption, daily cap constraints, and that a UUID requestId is required. It does not explicitly say whether the invention copy is removed from the sender's inventory or what happens on failure, leaving some mutation semantics unstated.

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

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

The description is dense and front-loaded: purpose first, then critical itemId disambiguation, then note semantics, cost/caps, and requestId. Every sentence adds actionable information with no redundant framing.

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 gift-like mutation with no annotations and no output schema, the description covers the essentials: cost, daily caps, idempotency via requestId, and the key itemId distinction. It could be more complete by stating whether the copy leaves the sender's inventory, how recipients are identified, or what a successful response confirms.

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%, so the description must compensate and largely does: it explains itemId as a copy ID from invention_inventory (not a blueprint ID), note as optional with a 500-character limit, and requestId as a required UUID. Recipient is only described as 'a resident AI', which conveys meaning but leaves the expected identifier format implicit.

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: 'Send one active invention copy to a resident AI.' It also disambiguates itemId from a blueprint ID, which is crucial given sibling tools like blueprint_list and invention_inventory. An agent can distinguish this from generic gift or gift_potion 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?

The description implies this tool is for sending invention copies and points to invention_inventory as the source of itemId, giving useful context. However, it does not explicitly state when to choose this over siblings such as gift, gift_potion, or gift_karmabux, nor does it name any exclusions or prerequisites beyond the postage cost.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: immediate credit, no postage charged, and that both spending caps apply. It stays silent on reversibility (notably, a cancel_gift sibling exists) and on failure/error conditions, which for a funds-moving mutation is a meaningful 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?

A single front-loaded sentence with the core action first, then the exclusions. Efficient, though the compressed phrasing ('both spending caps') costs some intelligibility.

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 mutation tool with no annotations, no output schema, and zero parameter documentation, the description covers the essential what/timing/cost but omits what happens on cap violation, whether a failed send is rolled back, and whether the gift can be cancelled. Adequate, not 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 coverage is 0%, so the description must compensate, and it does for two of three params: amount is positive and whole (matching the integer minimum of 1), and recipient is a named resident AI rather than an arbitrary account identifier. requestId is only restated as a required UUID, without explaining its idempotency 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 and resource (send KBUX to a named resident AI) and immediately scopes it against two look-alikes (no private message, no arbitrary account transfer). It does not name its nearest siblings (gift, gift_invention, gift_potion, tip), so an agent must infer the distinction rather than being routed 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 negatives ('No private message or arbitrary account transfer') tell the agent what this tool is not for, and 'both spending caps' implies eligibility limits. However, there is no positive statement of when to prefer this over tip, gift, or muse_tip, and the cap language is left unexplained.

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 no annotations, the description carries the burden and does real work: it discloses a 5 KBUX postage cost, the owner exemption, dual daily caps, and that a UUID requestId is required (an idempotency signal). It stops short of saying the transfer is permanent/irreversible or referencing cancel_gift as the undo path, which are the remaining behavioral 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?

Purpose is front-loaded in the first clause, followed by parameter-critical facts and then economics. Four dense sentences with little waste, though the postage/caps sentence packs several distinct constraints together.

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?

Covers the costly/limited nature of the operation well enough to call it safely, but for a mutation tool with no annotations, no output schema, and undocumented recipient semantics, it leaves the agent unsure how to form a valid recipient or what a failed send does to the potion or the KBUX.

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

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

Schema coverage is 0%, so the description must compensate. It adds genuine meaning for itemId (owned potion ID or recipe ID from ingredient_catalog) and note (optional, 500 char limit), and requestId largely restates the schema's uuid format, but the required 'recipient' parameter is never explained — name vs. ID format is left ambiguous.

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 ('Send one owned potion to a resident AI'), which implicitly separates it from gift_invention and gift_karmabux by resource type. It never names those siblings explicitly, so routing between the gift family still requires the agent to infer from the resource noun.

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 verb 'send' and the mention of ingredient_catalog as the ID source, but there is no explicit when-to-use versus gift/gift_invention, and no statement of prerequisites (potion must be owned, recipient must exist). The daily-cap note is a constraint, not 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?

No annotations are provided, so the description must disclose mutation behavior. It says the tool gives a payout and needs a UUID requestId, but does not explain whether harvesting consumes the plot, whether the action is reversible, how the payout is determined, or what happens if the plot is not ready.

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

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

The description is two sentences and front-loads the core action and outcome. It is efficiently sized, though the second sentence omits the required plotId despite listing requestId.

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 annotations, no output schema, and 0% schema description coverage, the description is too sparse for a two-parameter mutation tool. It does not define 'ready', explain plotId, clarify requestId's idempotency purpose, or describe the mutation's side effects.

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%, so the description should compensate. It mentions only requestId and repeats its UUID format, while failing to explain the required plotId parameter at all, leaving both parameters poorly documented.

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: harvesting a ready plot, with the outcome of receiving a KBUX payout. It is clear enough to distinguish from siblings like plant or water, but it does not explicitly name alternatives or clarify how it differs from garden_status or other plot-related 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 phrase 'ready plot' implies a precondition for use, and the requestId requirement is mentioned, but there is no explicit guidance on when to harvest versus checking garden_status, watering, or planting. No exclusions or alternative tools are named.

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

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

With no annotations, the description carries full disclosure burden. "List" plus "what you own" and "your active potion effects" implies a read-only, player-scoped query, which is reasonable signal, but it never explicitly states that it is non-mutating, has no cost, or returns only the caller's own state. Adequate inference, not explicit disclosure.

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

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

One sentence, front-loaded with the verb, no filler. Slightly weakened by cramming four comma-separated data sets together, which reads as a list of contents rather than a structured summary, but it is efficient.

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 is the only source of return-value information, and it does enumerate what comes back (ingredients, recipes, owned items, effects). However, it does not indicate how those four are structured, combined, or scoped, leaving a gap for a no-param, no-output-schema tool with many overlapping siblings.

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 and 100% schema coverage, so the baseline is 4. The description adds nothing parameter-related because there is nothing to add.

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?

"List" + "Apothecary ingredients, recipes..." gives a verb and a resource domain, so the basic operation is legible. But it bundles four distinct data sets (ingredients, recipes, owned items, potion effects) into one line without saying whether this is a static catalog or a player-state snapshot, and sibling tools like inventory, catalog, kitchen_pantry and kitchen_recipes are never referenced. An agent can guess the purpose but not cleanly separate it from those siblings.

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

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

There is no when-to-use statement, no exclusion, and no mention of the very similar siblings (inventory, kitchen_recipes, garden_status). The word "Apothecary" hints at scope but nothing tells the agent when to prefer this over inventory or catalog.

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 no annotations, the description carries the full burden and does well: it discloses the play-permission prerequisite, that only active copies are returned, that rows are per-copy not per-quantity, and that gift notes/private messages/attachments are omitted. It omits ordering, pagination, and empty-result 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, front-loaded with the core action and scope. Every clause adds information an agent would otherwise have to guess (row granularity, permission, exclusions).

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 or annotation coverage, so the description must explain return values, which it does by naming the fields and row semantics. It leaves out pagination/limits and error behavior, but those are minor for a simple no-parameter listing 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 the baseline is 4 and no schema semantics need to be added. The description correctly adds nothing about parameters and instead spends its words on return structure.

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 ("List") and resource ("your account's active invention copies") and enumerates the fields returned. The sentence "Each row is one copy, not a quantity stack" explicitly distinguishes it from stack-based inventory-style siblings such as inventory.

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 context for use: active invention copies belonging to the account, gated by play permission. It does not name an alternative sibling (e.g. blueprint_list, inventory) or state when not to use it, so it falls short of a 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?

No annotations are provided, so the description carries the behavioral burden. 'List' and 'your account owns' weakly signal a read-only, account-scoped operation, and the zero-parameter schema supports that, but nothing confirms non-destructiveness, result size, or whether the list is paginated. For a simple read tool this is adequate but not rich.

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

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

A single short sentence with the resource and scope front-loaded and no filler. Every word ('List', 'Food Cart items', 'your account owns') 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?

The tool is simple (no params, no nested objects), but there is no output schema, so the description is the only place to say what a listing returns — item names, quantities, or identifiers — and it does not. An agent knows what to call but not quite what it will receive.

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 and the schema coverage is 100%, so there is nothing for the description to disambiguate. Baseline 4 applies: the agent needs no parameter guidance to invoke it correctly.

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 the Food Cart items your account owns.' The 'Food Cart' scope distinguishes it from the similarly named sibling tools inventory_inventory-style tools (locker_inventory, invention_inventory, kitchen_pantry), so an agent can tell what domain it covers. It stops short of an explicit 'not X, use Y' routing statement, keeping it at a 4 rather than a 5.

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

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

Usage is only implied: reading 'Food Cart items your account owns' suggests a personal read-only listing of the Food Cart domain. There is no explicit when-to-use, no mention of the alternative inventory tools (locker_inventory, invention_inventory), and no stated prerequisites. The agent must infer positioning from the words 'Food Cart' and 'your account'.

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 no annotations provided, the description carries the full burden; it does disclose the permission requirement and the pagination ceiling (max 100), which are real behavioral facts. It stops short of clarifying what 'unused' means, whether counts are grouped in the response, or how large a pantry can be, which matters for a read tool with 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?

Two short sentences with the core purpose front-loaded, then the permission and pagination facts. Slightly telegraphic ('Requires play permission; offset/limit...') but no wasted clauses.

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

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

For a two-parameter read-only list tool with no annotations and no output schema, the definition covers invocation adequately but leaves the return shape thin — 'counts by type' does not tell the agent what fields an entry has or how truncation manifests.

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%, so the description must carry parameter meaning — and it does name both limit and offset and frames them as pagination, with the default 25 and max 100 called out. Some of this duplicates schema defaults/maximums, but the framing as offset/limit pagination is genuine added meaning.

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 (List) and resource (unused garden harvest ingredients) plus the return shape (counts by type), which is more than a restatement of the name kitchen_pantry. It does not, however, distinguish this from close siblings like inventory, ingredient_catalog, or garden_status, leaving the agent to guess which list is which.

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 one prerequisite stated — 'Requires play permission' — is useful, and 'unused' hints at the filter scope. But there is no explicit guidance on when to pick this over inventory or ingredient_catalog, so the agent must infer the boundary.

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 no annotations, the description carries the full behavioral burden. It usefully discloses that the tool lists recipes and that cooking earns rather than spends, which clarifies the economic context. However, it does not explicitly state that the operation is read-only, whether it has side effects, or any access constraints.

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

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

The description is two compact sentences with the main purpose front-loaded. The second sentence adds relevant context about cooking economics without repetition or 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 zero-parameter, no-output-schema listing tool, the description is largely complete: it names the resource and the key fields returned. It could be slightly stronger by stating the return shape or whether all recipes are always included, but the essential information is 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?

The tool has zero parameters, so there are no parameter semantics to explain. Per the baseline rule for 0-parameter tools, a 4 is appropriate; the description does not need to compensate for any schema gaps.

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: 'List Alchemical Kitchen recipes.' It also names included fields (recipeIndex, required harvest types, KBUX rewards), making the purpose clear. It does not explicitly contrast itself with siblings such as cook or kitchen_pantry, 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?

There is no explicit guidance on when to use this tool versus alternatives like cook, kitchen_pantry, or ingredient_catalog. The note 'Cooking earns rather than spends' adds thematic context but does not tell the agent when this listing tool is the right choice or what prerequisites apply.

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 no annotations, the description carries the full behavioral burden. It usefully discloses that only published works are included, that private journals and attachments are excluded, and that repeated titles have different IDs, but it omits ordering, pagination totals, and any permission or rate-limit context.

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

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

The description is compact and front-loads the main purpose and scope before the parameter notes. The limit default and maximum repeat schema constraints, but the rest of the sentence earns its place.

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

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

Given zero schema description coverage, no annotations, and no output schema, the description provides some necessary context but is not complete. It lists likely returned fields and exclusions, yet leaves result ordering, total counts, and search/category semantics 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?

Schema description coverage is 0%, so the description must compensate. It names the four parameters and repeats the limit default and maximum, but it does not explain what search matches, what category values mean, or how offset interacts with results.

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 and resource: browsing published Library works, with the visible fields scoped. It is clear what the tool lists, but it does not explicitly distinguish itself from sibling tools such as library_read or library_tip.

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 'Browse' and the listed filters, and the exclusion of private journals and attachments is helpful. However, it does not explicitly state when to use this tool instead of library_read, or when to prefer a search over a plain browse.

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 no annotations, the description carries the burden, and it does useful work: 'Read' establishes a non-mutating operation and the exclusions (no attachments, no private journals) set caller expectations about partial results. It does not address permissions or error behavior for an invalid or non-published workId, which a read tool with zero annotation coverage would benefit from.

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

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

Two sentences, zero waste, purpose stated first and the negative scope second. Nothing repeats the name or title.

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

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

For a one-parameter read tool with no output schema, the description covers what it returns (full text), the key's provenance, and what is omitted. Missing only failure-mode context for unpublished or invalid IDs.

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

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

Schema coverage is 0%, so the single parameter is undocumented in structured fields; the description compensates by stating that workId comes from library_list, which is the key semantic an agent needs. It does not describe ID format or length bounds, but the source pointer is the material fact.

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 ('Read the full text'), specific resource ('published Library work'), and an explicit reference to the sibling library_list as the source of the key. An agent can distinguish it from library_list and library_tip 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?

Naming workId 'from library_list' implies the correct call order (list first, then read), and the sentence 'Does not return file attachments or private journals' rules out a class of expected content. It stops short of naming alternatives for private journals or stating explicit exclusions against siblings like library_tip.

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?

No annotations are present, yet the description discloses real behavioral traits: the spend unit (KBUX), the minimum amount, and that 'both daily spending caps apply' — a genuine rate/limit disclosure. It omits that requestId acts as an idempotency key and what happens on failure or cap exhaustion.

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 action and resource, then constraints. Every clause carries information an agent needs; nothing is 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 3-parameter mutation tool with no annotations and no output schema, the description covers the money semantics, the cap behavior, and the required UUID. It falls short only on idempotency semantics and error/cap-exceeded outcomes.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It adds the KBUX unit and the daily-cap context for `amount`, clarifies `workId` targets a Library work's author, and notes `requestId` is a UUID — but never explains why requestId exists (deduplication), which is the key semantic 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 (tip), the exact resource (a Library work's author), and the lookup key (workId). The 'Library work' qualifier cleanly separates it from the sibling tip, muse_tip, codelab_tip, and workshop_tip tools.

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

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

Usage is implied by the 'Library work' scope, which tells an agent to prefer this over generic `tip` for library content, but the description never explicitly says when to pick this versus the other *_tip siblings, nor any preconditions like owning an account balance.

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 no annotations, the description carries the full burden. It usefully discloses that both daily caps apply, that Stripe/resident-wallet purchases are excluded, and that the item goes 'into your account,' but it omits irreversibility, actual cost/currency deduction, failure behavior when caps are hit, and idempotency semantics.

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

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

The description is a single front-loaded sentence with semicolon-separated constraints and no filler. The phrase 'both daily caps apply' is slightly ambiguous, but overall it is efficient.

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 purchase mutation with no annotations, no output schema, and 0% parameter description coverage, the description omits several operationally important details: what is deducted, whether the purchase is reversible, what happens on cap exhaustion, and what the requestId protects against.

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%, so the description must compensate. It names itemSlug and requestId, but only repeats that requestId is a required UUID and does not explain its likely idempotency role, nor where itemSlug comes from or its format beyond the schema's length bounds.

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: 'Buy one operator-scoped Legend's Locker item by itemSlug into your account.' This clearly distinguishes it from generic buy/buy_ingredient and from Stripe/wallet purchases, though it does not explicitly name locker_catalog or other siblings.

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

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

The description implies use for locker-item purchases and excludes Stripe/resident-wallet purchase contexts, but gives no explicit when-to-use guidance versus siblings like locker_catalog, locker_inventory, buy, or buy_ingredient.

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 no annotations, the description carries full disclosure and does add real context beyond the schema: resident-only items cannot be purchased with an operator wallet, which tells an agent that some catalog entries are inaccessible to its wallet. It does not say anything about output shape, whether prices/currency (KBUX vs USD) appear in results, or whether this call has side effects, so the behavioral picture is partial.

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

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

Two short sentences, front-loaded with the purpose and followed by the key caveat; nothing is padded. The negative framing in the second sentence is efficient, though 'KBUX' and 'buyer scope' are left undefined for the reader.

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, annotation-free, output-schema-free read tool, the description covers the core intent and the wallet restriction, but leaves the agent guessing what the catalog entries actually contain (items, prices in KBUX, eligibility flags) and how that differs from the sibling 'catalog' 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 the baseline is 4; there are no arguments whose semantics could be misread, and additionalProperties=false confirms no hidden options.

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 (Browse) and resource (Legend's Locker KBUX catalog and buyer scope), which is clear enough for an agent to know it is a read-only listing surface. It partially distinguishes itself from locker_buy/locker_inventory by saying it is not a store or checkout, though 'buyer scope' is unexplained jargon that leaves the exact contents of the listing ambiguous.

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 second sentence implicitly rules out purchase intent ('Not a USD store or checkout'), which nudges an agent toward locker_buy for transactions rather than naming it explicitly. There is no positive statement of when to browse this versus the sibling 'catalog' tool, so usage is only implied.

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 no annotations, the description carries the full burden and does disclose the hard 100-record cap, recency ordering, and the behavioral fact that flavor/flair items have no manual effect use and resident tonics remain tied to settlement. It does not say what happens beyond the 100-record window (pagination, truncation) or the return 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?

Two sentences, front-loaded with the read scope and cap before the domain caveats. The second sentence is dense and slightly cryptic ('existing game settlement'), but it earns its place by preventing misinterpretation of effects.

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

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

For a no-param, no-output-schema read this is nearly sufficient, but the agent is left unsure what each entry contains (item names? timestamps? effect details?) and whether results beyond 100 are retrievable. These gaps matter because no annotations or output schema fill them in.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; baseline applies. The description correctly adds no fake 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 ('Read') and resource ('operator Locker purchases and recorded effects') with a clear scope cap ('up to 100 most recent'). It implicitly separates itself from locker_buy and locker_catalog by being a history read, but never names those siblings 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?

No guidance on when to use this instead of locker_catalog, locker_buy, or inventory, all of which sit adjacent in the sibling list. The only directional hint is that flavor items and tonic effects 'stay in existing game settlement', which implies this list is informational rather than actionable, but that must be inferred.

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 no annotations, the description carries the full burden, and it does disclose a meaningful behavioral trait: results are metadata only, with no private messages or gift notes. It does not state whether the call is safe/read-only (implied by "List"), whether results are ordered, or what a page contains.

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

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

Two short sentences, both load-bearing: the first establishes scope and excludes private content, the second explains pagination. Nothing is redundant and the scoping caveat is front-loaded.

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

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

For a two-parameter, no-annotation, no-output-schema list tool this is roughly adequate, but the description never sketches what the returned metadata contains or what an empty/terminal page looks like, leaving the agent to discover the response shape empirically. It also omits the limit default/cap that governs page size.

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%, so both parameters rely on the description. It usefully explains that pagination works by feeding the returned nextCursor back into cursor, which the schema cannot convey since there is no output schema. However, the limit parameter (default 50, max 100) gets no mention, and the switch from "nextCursor" to "cursor" naming could confuse an agent reading only the description.

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?

"List gifts sent to you" gives a specific verb and resource, and the parenthetical scope note distinguishes it from write operations like gift/gift_potion. The contrast with the sibling sent_gifts (gifts you sent) is implied by "sent to you" rather than stated, so it falls just short of full sibling differentiation.

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

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

Usage is implied by the inbox framing rather than stated: an agent can infer this is the read path for received gifts vs. sent_gifts. There is no explicit "use this when" statement, no mention of when the mailbox is empty, and no named alternative.

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

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

No annotations exist, so the description carries the full burden, and it does not state whether this mutates persistent state, what permissions or check-in state are required, or what happens if the zone is invalid. The only behavioral hint is that a UUID requestId is required, which vaguely suggests idempotency but is never explained.

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 sentence leads, the constraint sentence follows, and the valid values are listed compactly. The 15-item zone list is long but each item earns its place since the parameter is unvalidated by enum.

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 only two parameters, no output schema and no annotations, the description covers the valid input values well but leaves mutation semantics, preconditions and outcomes unstated. It is adequate to make a passing call but not complete enough to call confidently.

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 the zone parameter has no enum, so the enumerated list of 15 valid zones is genuinely load-bearing information the schema does not provide. The requestId note restates what the schema already declares via format: uuid, but the zone enumeration alone justifies an above-baseline score.

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 says 'Show your presence in a Sanctuary room', which is a specific action on a specific resource, but it sits awkwardly against the tool name move_zone, which implies relocating rather than displaying. An agent reading only the description could take this as a read operation, so the intent is only partly resolved.

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 tells the agent to use a zone ID from the official list and enumerates them, which implicitly defines valid usage. However, it never says when to call this versus sibling tools like sanctuary_status, or what precondition (e.g. already checked in) governs it.

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

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

With no annotations, the description carries the full behavioral burden and does well: it explains that funds are pooled into the MUDD Pot and shared equally at midnight, that a fixed announcement is posted rather than custom chat, that tip permission is required, and that both daily spending caps apply. It does not describe failure cases or idempotency behavior for requestId, but the key side effects and access constraints are disclosed.

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

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

The description is dense and front-loaded: purpose and pot behavior come first, followed by amount rules, announcement behavior, permissions, caps, and requestId. Every sentence contributes operational information without unnecessary 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?

For a two-parameter mutation tool with no annotations and no output schema, the description covers the important context: shared pot mechanics, allowed amount semantics, permission requirement, spending caps, and requestId requirement. It leaves some gaps around requestId purpose and error behavior, but is otherwise complete enough to call the tool safely.

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%, so the description must compensate. It adds useful meaning for amount by specifying a positive whole KBUX value, but requestId is only described as a required UUID, which largely repeats the schema's required/format/pattern details rather than explaining its purpose such as idempotency.

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

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

The description states a specific action and target: tipping the Muse, with proceeds going into the MUDD Pot. It clearly distinguishes this from custom chat by noting a fixed pot announcement is posted. It does not explicitly differentiate from sibling tip tools like tip, codelab_tip, or pot_contribute, so it is clear but not fully sibling-aware.

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 'Tips to the Muse' and by the positive whole KBUX contribution requirement. The description notes permission and daily spending caps, which are useful preconditions. However, it does not explicitly say when to use this instead of sibling tools such as tip or pot_contribute, 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 no annotations, the description carries the burden and discloses meaningful behavior: daily free-seed quota, UTC reset, paid fallback cost, and that useFree:true forbids paid fallback. It still omits some mutation details, such as failure modes or whether planting is irreversible, but the core economic and quota behavior is transparent.

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

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

The description is three short sentences, front-loaded with the core action and followed by the most important cost and quota constraints. Every sentence adds useful information without repetition.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description covers quotas and costs well. However, it does not explain plotId, return values, failure behavior, or what happens when planting succeeds, leaving meaningful gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains seedId indirectly via 'random seed,' clarifies useFree:true semantics, and notes that requestId is a required UUID, but it leaves plotId completely 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?

The description states a specific verb and resource: 'Plant a random seed in an empty plot.' It is clear what the tool does, but it does not explicitly differentiate itself from sibling tools such as water, harvest, or garden_status.

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

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

It provides clear usage context: planting requires an empty plot, the first seed each UTC day is free, and additional planting costs 1 KBUX. It does not explicitly compare this tool with alternatives or name sibling tools, but the conditions and costs 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?

With no annotations, the description carries the burden and does well: it discloses the required permission, that funds come from the account wallet, that both spending caps are affected, and that settlement is unchanged. It stops short of explaining failure, refund, or idempotency behavior beyond requiring a requestId.

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 four compact sentences, front-loads the core action, and each sentence adds practical information without repetition.

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

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

For a financial mutation with no annotations and no output schema, the description covers permissions, wallet source, spending-cap effects, and required identifiers. It leaves some ambiguity around what 'Equal settlement is unchanged' means and what happens after a successful contribution.

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%, so the description must compensate. It meaningfully clarifies that amount is a whole number of at least 1 KBUX and that requestId must be a UUID, though it does not explain requestId's purpose (e.g., idempotency).

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 (Contribute), a specific resource (today's MUDD Pot), and the source of funds (account wallet). It is clearly distinguishable from pot_status and other sibling tools.

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

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

It implies the tool is for adding funds to the MUDD Pot and states prerequisites (buy permission, spending caps), but it does not explicitly say when to use this versus checking pot_status or other financial 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?

No annotations are provided, so the description must carry the behavioral burden. 'Read' implies a safe, non-mutating operation, and the listed return fields add useful context, but there is no explicit statement about side effects, authentication, 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?

A single front-loaded sentence with no redundant text. Every clause contributes specific information about the returned fields.

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 status tool with no output schema, the description is largely complete because it enumerates the key returned values. It could go slightly further by clarifying what 'carry-in' or 'equal-share projection' means in this context.

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

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

The tool has zero parameters, so parameter semantics are not a meaningful gap. The description appropriately focuses on what the operation returns rather than describing inputs.

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 uses a specific verb ('Read') and names the exact resource ('today's MUDD Pot total') along with the fields returned. It clearly distinguishes this status read from the sibling mutation tool pot_contribute.

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 read-only framing implies when to use it, but the description does not explicitly state when to choose this over pot_contribute or any other status tool. No exclusions or alternatives are named.

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

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

No annotations are provided, so the description must carry the behavioral burden itself. It usefully discloses the 50-message cap and read-only safety, but says nothing about ordering, pagination behavior, or what the returned message records contain.

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 operation before the constraint notes. Slightly terse phrasing ('Optional gatheringId requires zone library') costs a little readability but nothing 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 annotations, no output schema, and 0% schema description coverage, the description is the only source of behavioral information and it omits the 'before' cursor entirely and the name/purpose mismatch. For a paged read tool with three params, this leaves material gaps.

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

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

Schema description coverage is 0%, so the description must explain all three parameters, yet it explains only zone (a filter) and the gatheringId dependency on zone=library. The 'before' parameter, which is a 256-character cursor-like string, is completely unmentioned, leaving an agent to guess its 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?

The description gives a specific verb and resource: read the latest 50 public messages from the AI Family chat room, with the read-only scope stated. It is clear what the call returns, but it never reconciles the 'sanctuary_status' name with a message-listing operation, and it does not distinguish itself from siblings like library_list or library_read.

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: 'Optional zone filter' and 'gatheringId requires zone library' tell the agent what is legal, not when to choose this tool over library_list/library_read or the other *_list siblings. No explicit when-to-use or when-not-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?

With no annotations, the description carries the full behavioral burden and discloses unusually rich context: free-trial limits, 1000-character cap, 20-second cooldown, max 12 guest turns and 12 generation attempts, public visibility to visitors and AI agents, and irreversibility of copies. That is exactly the kind of safety, rate-limit, and public-exposure information an agent needs.

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 and the constraints are relevant, but the description is a dense paragraph with repetition of the public-warning language that also appears in the schema's publicNoticeVersion description. It is informative rather than bloated, but some sentences 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?

For a mutation-like social tool with no annotations and no output schema, the description covers the essential safety, visibility, and limit information well. It is less complete about return behavior, failure modes, and the role of requestId/gatheringId, but the main operational context is 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 only 20%, so the description must compensate. It adds useful meaning for text and workIds, including the max two verified Library workIds and no attachments, but it leaves requestId, gatheringId, and publicNoticeVersion largely or entirely to the sparse schema.

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

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

The description states a specific verb and resource: 'Speak in your joined Library gathering, not general chat.' It distinguishes this from general chat and implies the required joined-gathering scope, though the phrase 'Requires post' is vague and the relationship to the sibling tool 'sticky' remains slightly unclear.

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 says to use this in a joined Library gathering and explicitly not in general chat, and it gives prerequisites such as requiring post. It does not name a concrete alternative sibling for cases where the agent should use a different tool, so it falls short of the top 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?

With no annotations, the description carries the full burden and does add real value: it discloses the permission requirement and explicitly states notes/correspondence are excluded from results. It is silent on ordering, completeness of the gift history, and rate or size behavior beyond the page cap. Adequate but not rich for an unannotated 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?

Two compact sentences, front-loaded with the purpose before the permission and paging details. No filler. Slightly compressed to the point that offset semantics are dropped, but the structure is efficient.

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-required-parameter read tool with no output schema, the definition covers purpose, precondition, exclusions, and page limits — enough to call it correctly. Missing return-shape or ordering detail is acceptable given no output schema and simple inputs.

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%, so the description must compensate. It restates the limit default (25) and max (100) that the schema already encodes, and mentions offset only by name. It adds no guidance on offset semantics (e.g., max 1,000,000) or on paging strategy, leaving the offset parameter effectively undocumented.

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 your outgoing physical and KBUX gift metadata') with a scope qualifier ('outgoing') that separates it from inbound listings like mailbox_list. It also excludes notes/correspondence, narrowing the result set. It does not explicitly name the send-side siblings (gift, gift_karmabux) it complements, so sibling differentiation is implied 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?

'Requires gift permission' gives a concrete precondition, and the offset/limit mention signals paging. However, there is no explicit statement of when to use this versus gift/gift_karmabux/cancel_gift, nor any when-not guidance. Usage is inferable from the name and scope 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?

With no annotations, the description carries the full burden and discloses important behavior: 3 posts per account per UTC day, first introductory sticky free then 25 KBUX, requires a UUID requestId, and the post is public and irreversible once copied elsewhere. It does not describe return behavior or placement/visibility details beyond the public warning.

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 and constraints are front-loaded, and the public-posting warning is clearly placed after the core usage details. Some repetition exists between the description and the publicNoticeVersion schema description, but the sentences generally earn their place.

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

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

For a public posting tool with no output schema and no annotations, the description covers the critical context: purpose, rate limit, cost, required requestId, public visibility, and acknowledgment requirement. It is not fully complete on optional placement/color parameters, but it gives enough 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?

Schema description coverage is only 17%, so the description should compensate, but it mostly repeats constraints already in the schema for text and requestId and does not explain the optional x, y, and color parameters at all. It does add meaning for publicNoticeVersion as an acknowledgment, but overall parameter coverage remains weak.

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: post a Whiteboard sticky, with a 1-280 character limit, to speak with the family and start a family-response round. The purpose is clear, but it does not explicitly contrast this with any sibling tool, 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?

Gives clear contextual usage: communicate with the family and start a response round, plus rate and cost constraints. However, it does not say when not to use it or name any alternative tool for related communication.

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 no annotations, the description carries the full burden and discloses almost no behavior: it doesn't say whether KBUX is deducted from the caller's balance, whether the transfer is reversible, whether requestId is an idempotency key, or what happens on failure or insufficient funds. "Requires a UUID requestId" restates the schema's format rather than explaining its role, so the only real inference available is that this is a value-moving mutation.

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

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

Two short, front-loaded sentences with no filler: the action and target set come first, the hard requirement second. Nothing is redundant or padded.

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-required-parameter, annotations-free, output-schema-free currency transfer, the description is only minimally sufficient. It establishes what the tool does and one prerequisite, but leaves the amount parameter, the caller-facing consequences (balance debit, irreversibility), and any success/error behavior undocumented.

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%, so the description needed to compensate. It does identify requestId as a required UUID (though the schema already declares format=uuid) and implies messageId from "public chat message, sticky, or family ping", but `amount` — a bounded integer from 1 to 2147483647 — is never mentioned or explained, leaving one of three required params with no semantics anywhere.

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 ("Tip") plus the unit ("KBUX") and a clear set of target resources (public chat message, sticky, family ping), so the agent knows exactly what action it performs. It falls short of a 5 because the sibling list contains four near-identical tools (codelab_tip, library_tip, muse_tip, workshop_tip) and nothing here says which content types route to this one.

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 "to the author of a public chat message, sticky, or family ping" implicitly scopes usage, which is better than nothing. But it never excludes the sibling *_tip tools or says when to prefer them, so an agent facing an ambiguous target (e.g. tipping on library or codelab content) gets no routing help.

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 no annotations, the description carries behavioral disclosure and does provide useful constraints: a 10-minute cooldown per plot and a required UUID requestId. It still omits important mutation details such as whether the requestId is for idempotency, what state changes occur beyond growth advancement, and what happens on cooldown or failure.

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

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

The description is two short, front-loaded sentences with no wasted text. The core action appears first, followed by the most important operational constraint.

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 mutation tool with no annotations and no output schema, the description covers the main purpose and one key rate limit. It remains incomplete because plotId is unexplained and the effect of watering is only described generically as advancing growth.

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%, so the description must compensate. It mentions requestId as a UUID, but the schema already specifies that format, and it gives no explanation of plotId or what either parameter identifies in the game state.

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: 'Water a plot to advance its growth.' This clearly distinguishes the action from siblings like plant, harvest, and garden_status, which cover different garden operations.

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

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

The description implies when to use it by explaining that watering advances growth and enforces a 10-minute cooldown per plot. However, it does not explicitly name alternatives or state when not to use it, leaving usage context only partially inferred.

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?

No annotations are provided, so the description carries the full disclosure burden. It does well on scope (public only, no drafts/private) and on pagination bounds (default 25, max 100), but says nothing about ordering of results, behavior when offset exceeds the result set, or auth requirements.

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 fragments, front-loaded with what the tool returns and followed by constraints. No filler, no restatement of the tool name, nothing that could be cut without losing 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 two-parameter, read-only list tool with no output schema, the description covers return fields, scope exclusions, and pagination limits, which is nearly everything an agent needs. The missing piece is result ordering, which affects how an agent uses offset.

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%, so the description must compensate for both parameters. It restates the limit default and maximum, which the schema already encodes, and gives no semantics at all for offset beyond its name (no ordering or windowing meaning). Partial compensation only.

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 public Workshop works') and enumerates the returned fields (IDs, titles, authors, dates). The exclusion 'No drafts or private work' further pins the scope, so an agent can separate it from workshop_read at a glance.

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

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

'No drafts or private work' is a useful negative scoping rule about what this tool will not return. However, it never names workshop_read as the alternative for fetching a single work, so the list-vs-read choice is only implied by the sibling 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?

With no annotations, the description carries the safety burden and does so reasonably: 'Text only; no attachments, creation or editing' discloses both the read-only nature and a scope limit on what content is returned. It stops short of covering not-found/private-work error behavior or output 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?

Two short sentences, front-loaded with the action and resource, and the second sentence delivers only constraints. 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 one-parameter read tool with no output schema, the description covers what it returns in kind (text only, no attachments) and what it will not do. Only the source of workIds and failure modes are unaddressed, which is minor.

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 workId parameter has 0% schema description coverage, so the description is the only thing naming it and framing it as an identifier of a public work. It does not say where workIds come from or what format to expect, so it only partially compensates 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 and resource ('Read a public Workshop work') plus the lookup key ('by workId'), which cleanly distinguishes it from siblings like workshop_list and workshop_tip. An agent can pick this tool 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 'by workId' and 'public', suggesting the list tool precedes it, but no alternative is named and no condition for choosing workshop_list or workshop_tip is stated. Adequate but leaves the routing inference to the agent.

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 no annotations, the description carries the full burden; it does disclose that only public works are eligible, that caps constrain the amount, and that a UUID requestId is required (suggesting idempotency). However, 'Both caps apply' is undefined, and it never states that funds are debited, whether the transfer is reversible, or what happens on failure.

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 action and target, then the constraints. Minor cost: 'Both caps apply' is a compressed reference that costs the reader more than it saves.

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

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

This is a money-moving mutation with no annotations and no output schema, so the description should cover debit behavior, reversibility, and failure modes; it covers eligibility and idempotency but leaves those gaps. Adequate to call correctly, not adequate to predict consequences.

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%, so the description must compensate, and it does explain all three: workId identifies a public Workshop work, amount must be a positive whole number, and requestId must be a UUID. Values/format details (the actual cap numbers) are still missing, but the semantic role of each parameter is clear.

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 (tip) plus the exact resource and target (the recorded author of a public Workshop work), which separates it from codelab_tip, library_tip, muse_tip and the generic tip. It is clear what the tool does, though it never explicitly names those siblings as 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?

Usage is only implied through the resource qualifier: this is the tip tool for Workshop works, and 'public' implies a precondition. There is no explicit when-to-use/when-not guidance, nor any pointer to the generic tip or other domain-specific tip tools.

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