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

With no annotations, the description carries the full behavioral burden. It helpfully discloses that episodes are appended and numbered after existing ones, and that buyers see them, but it does not cover permissions, failure modes, or what is returned.

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 concise sentences, front-loaded with the action and scope, followed by useful buyer-visibility context. There is no wasted text.

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

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

The description covers purpose, ordering, and visibility, which is useful for a mutation tool with no annotations. However, it omits permissions, error behavior, and return expectations, and there is no output schema to compensate.

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

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

Schema description coverage is 100%, so both parameters are already well documented in the schema. The description adds no parameter-level detail beyond implying that episodes go to the end of the series.

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: adding episodes to the end of an existing series. It also clarifies append placement and numbering after existing episodes, which distinguishes it from create_series.

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

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

It clearly establishes the context for use: an existing series that needs additional episodes at the end. It does not explicitly name exclusions or alternatives, but the intended scenario is unambiguous.

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

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

With no annotations, the description carries the full burden and delivers unusually rich behavior detail: deduplication of blank lines and repeats, 200-character item limit with skipped items counted, pre-existing pool items counted rather than re-added, batching of 100 per send, and a 1000-item pool cap. It omits permissions/auth requirements and what is returned, which keeps it from a 5.

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

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

Compact and front-loaded: purpose first, then input mechanism, then edge-case behavior. The final sentence is somewhat compressed ('Sent 100 at a time; a pool holds up to 1000 unused items') but every clause carries information.

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

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

For a mutation tool with no annotations and no output schema, the description covers normalization rules, error-adjacent edge cases, batching, and capacity limits. Missing details are secondary: required permissions and whether partial successes are reported back.

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 67%; `items` carries no schema description, and the description compensates by defining it as the list to add and explaining the either-or relationship with `file` plus the one-item-per-line file convention. It adds real meaning beyond the schema, though it does not echo the code pattern or size limits that the schema already states.

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

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

States a specific verb and resource ('Add items ... to a Gated link's pool') and immediately clarifies the domain concept ('each delivered order takes one'), which distinguishes it from sibling read tools like get_pool_stats and list_links.

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

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

Explicitly tells the agent that either `items` or `file` must be supplied and explains the file format ('a text file, one item per line'), which resolves the main decision the caller faces. It does not, however, state when not to use this tool or point to an alternative for bulk/other operations.

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 only destructiveHint available in annotations, the description adds critical context: the action is irreversible, it fulfills the consumer's purchase, and it charges the sales fee. These side effects and the approval prerequisite go well beyond the structured annotation.

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: the first states the action and consequence, the second gives the prerequisite and irreversibility warning. It is front-loaded and every clause earns its place.

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

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

For a one-parameter destructive tool with no output schema, the description covers the essential behavioral traits: what it does, the consumer and fee consequences, the creator-approval prerequisite, and irreversibility. Nothing critical is missing.

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

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

Schema description coverage is 100% and the single orderId parameter is documented in the schema. The description references 'this order' but adds no format or constraint details beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Confirm that a payment on hold belongs to this order') and explains the outcome, making the action clear. It does not explicitly name the opposing sibling tool reject_payment, so it falls 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?

It gives a clear precondition ('Only do this after the creator has said so') and a strong warning ('it can't be undone'). However, it does not explicitly mention when to use reject_payment instead, leaving alternative selection partly to inference.

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

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

With no annotations the description carries the full burden, and it does disclose real behavior: file formats, 20 MB cap, 1–20 item range, direct upload to the creator's own storage zone, and that one image serves as the cover. However, nothing is said about permissions/auth, whether the local files are moved or copied, reversibility of the listing, or failure modes - all material for a mutation 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?

Three tightly packed sentences that front-load the core action and constraints with no filler. Minor deduction because the trailing clause about the cover being 'blurred or not on the landing page' is vague and reads as an afterthought rather than actionable 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 an 8-parameter mutation with no annotations and no output schema, the description covers media constraints and storage destination but omits prerequisites, side effects, and what the caller gets back. It is adequate but leaves the agent guessing about the operational consequences of creating a listing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the images constraint (1–20 pictures, accepted formats, 20 MB) and hints at coverIndex behavior via the cover sentence, but adds no syntax or format detail beyond what the schema already documents.

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 ('Sell a gallery of 1–20 pictures') plus format and size constraints, which cleanly separates it from siblings like create_video, create_series and create_link. It also names where the content lands (the creator's own Bunny Storage zone), so the agent knows this is a media-hosting sale listing, not a generic link tool.

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

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

The picture-only framing implies when to use it (selling image galleries rather than videos or series), but there is no explicit when-to-use statement, no exclusions, and no routing advice toward sibling creation tools. Usage is inferable rather than stated.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does disclose the critical immutability constraint ('Its destination can never be changed afterwards'). However, it says nothing about authentication requirements, whether the operation is idempotent, rate limits, or what the call returns – gaps that matter for a 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?

Three short sentences, purpose front-loaded, zero filler. Each sentence carries a distinct payload: what it does, its immutability constraint, and the follow-up tool to call.

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

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

For a single-parameter create tool with no output schema and no annotations, the description covers the essentials, including the irreversible-destination constraint. It doesn't indicate what the response contains (e.g. the generated short link/identifier), which an agent would need since no output schema exists – a minor but real gap.

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

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

Only one parameter (targetUrl) and schema description coverage is 100%, so the schema already documents the URI format and http/https constraint. The description's 'destination URL' phrasing adds no meaning beyond what the schema supplies; baseline 3 applies.

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

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

States a specific verb and resource: 'Create a short link to a destination URL.' That is immediately distinguishable from the read-side siblings (list_links, get_link) and from the follow-up mutation tool set_paywall without opening any schema.

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

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

Gives explicit sequencing guidance: 'To sell it, call set_paywall on it next,' which routes the agent to the correct follow-up tool. It stops short of stating when NOT to use this tool or what alternatives exist for other link workflows, so it falls just under 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?

With no annotations, the description carries the behavioral burden and discloses real context: files are pushed straight to the creator's Bunny Stream library (an external destination), a hard cap of 100 episodes, ordering semantics, and the readiness condition for accepting orders. It omits permissions, failure behavior, and whether re-invocation is idempotent, but the mutation's side effects are unusually well surfaced.

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 sentences, front-loaded with the commercial purpose before constraints and ordering rules. Parentheticals are dense but each carries information (what a series is, natural sort order), with no filler.

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

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

For a 10-parameter creation tool with no annotations and no output schema, the description covers destination, ordering, limits, and readiness well, but says nothing about the return value (siblings like get_upload_job imply an async upload job) or auth/permission requirements. Adequate but leaves a notable gap for the caller.

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 already 90%, so the baseline is 3; the description earns above that by adding meaning the schema lacks, notably the 100-episode limit (the schema's episodes array only sets minItems) and the coupling of freeCount to the readiness rule ('at least freeCount + 1 episodes'). The folder natural-name-ordering note reinforces the episodes parameter's dual string/array form.

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: sell a series of episodes (short drama / web series) for one price with the first few free. The parenthetical defines the domain concept and implicitly distinguishes it from create_video and create_gallery, though it never names those siblings. An agent can tell what this tool creates without opening the schema.

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

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

Usage is implied by the domain description (multi-episode monetized series) and a readiness precondition is given: 'takes orders once at least freeCount + 1 episodes (and at least 2) are ready.' There is no explicit when-to-use-vs-alternative routing, so the agent must infer that add_episodes / create_video are the other paths.

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 disclose two non-obvious traits: files are uploaded to the creator's own third-party Bunny Stream library, and the listing does not accept orders until encoding completes (an asynchronous gate). It still omits permissions/auth requirements and failure handling, which keeps it from a 5.

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

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

Two tightly written sentences, no filler. The core purpose is front-loaded and the second sentence adds the storage/encoding behavior that an agent needs before calling.

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 an 8-parameter mutation tool with no annotations and no output schema, the description covers the storage destination and the encoding gate but not the return value — notably it never mentions that this likely produces an upload/encoding job the agent must poll via get_upload_job, nor the wallet prerequisites implied by payoutWalletIds.

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

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

Schema description coverage is 100%, so the schema already explains all 8 parameters (price format, preview clip being a separate file, payoutWalletIds defaults, verifyPayer credit cost). The description adds only the high-level note that previewClip is optional, so baseline 3 applies.

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

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

States a specific verb and resource (sell/create a video listing) and clarifies the source of the file ('from this computer'), which separates it from URL-based siblings like create_link. It does not explicitly name which sibling to use instead of this one (create_gallery, create_series, add_episodes), so it stops short of full 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 rather than stated: 'Sell a video from this computer' tells the agent this is for locally-stored single videos, but there is no explicit when-to-use/when-not, no mention of prerequisites such as having a payout wallet configured, and no routing to create_gallery/create_series for multi-item cases.

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

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

With readOnlyHint=true already declaring a safe read, the description adds only that paywall settings are included. It does not mention error behavior, authentication, or what fields the returned link contains. Minimal added behavioral 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?

Five words, no filler. However, the fragment omits a verb and could be slightly more informative without losing conciseness. Still 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 simple read tool with a fully documented parameter and readOnly annotation, the description conveys the return focus (link + paywall settings). But with no output schema, it doesn't list returned fields or mention not-found behavior. Adequate but with 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 coverage is 100%, and the single 'code' parameter is fully described in the schema. The description adds no further parameter detail, so baseline 3 applies.

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

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

The description identifies the resource ('One link') and highlights an included aspect ('its paywall settings'), but it is a noun phrase without a verb like 'retrieve' or 'fetch'. It distinguishes from list_links by singular but does not explicitly name siblings or state the action.

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

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

No guidance on when to use this tool versus alternatives such as list_links or get_vault_item. The description provides no context, exclusions, or prerequisites.

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?

readOnlyHint=true already establishes this as a safe read, so the description's main added value is disclosing that a payment under review may be included in the response. That is genuinely useful return-shape context absent from structured fields, but it says nothing about behavior when no such payment exists or about authorization 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?

A single short sentence with the resource front-loaded and no wasted clauses. The trailing qualifier "if there is one" is slightly cryptic but carries real conditional information rather than filler.

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

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

With no output schema, the description is the only source for return expectations, and it only hints at one component (payment under review). It omits what the order object otherwise contains, error behavior for unknown ids, and access requirements, leaving meaningful gaps for a lookup tool.

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

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

Schema description coverage is 100% and the single orderId parameter is fully documented by the schema's pattern and description, so the baseline is 3. The description adds no format, provenance, or lookup guidance beyond what the schema already provides.

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

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

"One order" conveys the resource and singular scope, which implicitly contrasts with the sibling list_orders, and it notes the tool also surfaces a payment under review. However, it never names a verb (fetch/retrieve) or explicitly distinguishes itself from list_orders or get_link, so the purpose is only 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?

There is no when-to-use guidance, no mention of the alternative (list_orders) for enumerating orders, and no prerequisites such as required authentication or ownership of the order. The agent must infer invocation context entirely.

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

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

readOnlyHint=true already establishes this as a safe read, so the description's main added value is clarifying what the numbers mean (remaining vs. allocated). It does not disclose units, whether 'left' accounts for pending orders, or any rate/auth considerations, so it goes only modestly beyond the annotation.

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 compact sentence with no filler. The phrasing is slightly awkward ('Gated link's pool has left') but information-dense and 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?

With no output schema, the description does the minimum by naming the two returned counts, but gives no field names or shape. For a simple single-param read tool that is borderline adequate, leaving an agent to discover the actual response format.

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

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

Schema description coverage is 100%, and the single 'code' param is fully documented in the schema with its pattern and meaning. The description adds nothing about parameters, so the baseline 3 applies — the schema carries the load.

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

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

The description states what is returned — remaining pool items and items already allocated to orders — for a 'Gated link'. However, it is phrased as a question about quantities rather than a clear verb+resource statement, and it never explicitly names 'pool stats' or distinguishes itself from the sibling get_link, which also concerns a link's state.

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

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

There is no guidance on when to call this versus get_link, list_links, or list_orders. An agent must infer from the name alone that this is the tool for checking pool availability before adding items or assessing scarcity.

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

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

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds a meaningful behavioral detail: omitting jobId returns recent jobs rather than failing. It does not disclose pagination, rate limits, or what the status payload contains, so beyond the default-behavior note it is fairly thin.

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, zero waste. The core purpose is front-loaded, and the default behavior when jobId is omitted follows immediately. Nothing is repeated from the 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 simple read tool this covers the call decision well. However, with no output schema, the description never specifies what a job's status response contains (state, progress, errors), leaving the agent uninformed about the return shape.

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

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

Schema coverage is 0%, and the single jobId parameter is undocumented in the schema. The description compensates by explaining jobId selects a specific upload while its absence defaults to a list of recent jobs, which is exactly the semantic an agent needs to choose between the two call forms.

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

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

The description states the resource (upload job) and exactly what it reports: how an upload started by create_gallery, create_video, create_series, or add_episodes is progressing. It also distinguishes itself from those creation siblings by positioning itself as the status-query counterpart, so an agent can tell which tool actually starts an upload and which reports on it.

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

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

Usage context is clear: call this to check on an upload initiated by one of the four named creation tools, or omit jobId to list recent jobs. It does not state explicit exclusions or name alternative status tools, but the triggering condition is unambiguous enough for selection.

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

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

The readOnlyHint annotation already establishes this as a safe read. The description adds useful context about the returned state values and conditional series episode count, but does not mention error behavior, permissions, or not-found handling.

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

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

It is a single compact sentence with no wasted words, and the key scope and return fields are front-loaded.

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

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

For a simple one-parameter read tool with no output schema, the description covers the main returned fields and state values adequately. Minor gaps around failure cases and full return shape remain, but the essentials are present.

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

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

Schema coverage is 100% and the single 'code' parameter is fully documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description states it returns a single Vault item and names the key fields exposed, which is enough to distinguish it from list_vault. It is slightly implicit about the retrieval verb, but the resource and scope are clear.

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

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

Use is implied by 'One Vault item' and the required short-code parameter, since an agent can infer this is for fetching a known item. However, there is no explicit guidance on when to use this versus list_vault or other sibling tools.

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

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

Annotations only declare readOnlyHint=true, so the safety profile is covered, but the description adds real behavior the agent could not otherwise know: result ordering ('newest first'), a concrete page size (ten), and the cursor round-trip contract. This is meaningful value beyond the annotations, though it says nothing about what a link object contains or whether filters affect pagination.

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

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

Two sentences, zero filler, and the most important fact (what the collection is plus its ordering) is front-loaded before the pagination mechanic. Nothing here 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?

With no output schema, five parameters, and low schema coverage, the definition should say more. It covers pagination well and the read-only nature is handled by annotations, but it never characterizes the returned link items or explains the filter parameters, leaving the agent to infer the tool's full capability.

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% (just q is documented), so the description must compensate and largely fails to: tag, kind, status and the enum meanings are left entirely to the schema. It does give cursor an operational meaning via the nextCursor round-trip, which is one useful addition out of five parameters.

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

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

The description names the resource and its scope precisely ('The account's links') and adds ordering ('newest first') plus page size, which implies a paginated collection read distinct from the sibling get_link. It stops short of an explicit verb and never contrasts itself with list_vault or the filtering 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 procedural guidance for continuing pagination ('Pass nextCursor back as cursor for the next page'), which is genuinely useful. However, nothing says when to call this versus get_link for a single link, or how the q/tag/kind/status filters should be combined to narrow results.

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?

readOnlyHint=true already establishes this as a safe read. The description adds genuinely useful non-annotation context: ordering (newest first), pagination size (ten a page), and the meaning of the 'hold' status. It stops short of explaining cursor semantics or the result shape, so it adds value but not rich behavior detail.

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

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

Two tight sentences with no filler, and the most important information (what is listed, in what order, at what granularity) is front-loaded before the status clarification.

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

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

For a simple two-parameter list tool with no output schema this covers the essentials, but with 0% schema description coverage the description should have explained the cursor/pagination contract and the remaining status values (pending, delivered, expired, rejected, all). As written, an agent must guess at both.

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, and it largely does not. It explains only the 'hold' enum value out of six possible statuses and never explains what cursor is or how to advance pages, despite 'ten a page' implying the cursor is a page token.

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

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

States the resource (the account's orders) plus its ordering (newest first) and page size (ten a page), which is more specific than a bare 'list orders'. It doesn't explicitly distinguish itself from the singular sibling get_order, but the plural/scope framing makes the collection intent clear.

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

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

Usage is only implied: it references confirm_payment / reject_payment as the actions for 'hold' orders, which gives a routing hint toward siblings, but there is no explicit statement of when to call list_orders versus get_order, nor any prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, so safety is covered; the description goes beyond that by disclosing result ordering ('newest first') and page size ('ten a page'), both of which change agent behavior (it must loop). It does not mention auth scope beyond 'the account's' or any rate limits, so it is strong but not exhaustive.

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

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

A single front-loaded sentence naming resource, contents, ordering, and page size with zero filler. Nothing could be removed 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?

With no output schema, the description does describe the returned item types and ordering, which is helpful. However the cursor parameter is undocumented in both schema and description, leaving the agent without the information needed to actually paginate. Adequate but with a concrete gap.

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

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

Schema coverage is 0% for the single optional cursor parameter, so the description must compensate. 'Ten a page' implies pagination and thus a cursor, but the description never explains what the cursor is, where it comes from, or how to advance pages. Partial compensation, baseline 3.

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

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

States a specific verb (list) and resource (the account's Vault items) and enumerates the item subtypes it returns (galleries, videos, series), which clearly separates it from the singular get_vault_item sibling. It stops short of explicitly naming that sibling as the alternative, so it is clear but not fully differentiated in prose.

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

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

There is no when-to-use or when-not-to-use statement and no named alternative. Usage is only implied: the tool is obviously for browsing the account's Vault, and 'ten a page' signals the agent should be prepared to page. That is adequate but leaves the agent to infer the split with get_vault_item.

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

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

With readOnlyHint already declaring the safe-read behavior, the description adds useful context: wallets are per-network, their ids are consumed by paywalls, and wallet creation happens only in the dashboard. It does not describe return format or pagination, but the annotation covers the safety profile.

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 with the resource front-loaded and no redundant explanation. Every sentence adds a distinct fact about wallets, their ids, or their creation 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 zero-argument read-only listing tool with no output schema, the description covers the key context: what is listed, that ids are one per network, and that wallets cannot be added through this API. A brief note on return ordering or fields could help, but nothing critical is missing.

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

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

This tool has zero parameters, so there are no parameter semantics to explain. The baseline for a parameterless tool is 4.

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

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

The title supplies the verb 'List' and the description identifies the resource as 'The account's payout wallets,' making the purpose clear. It does not differentiate this tool from siblings such as list_vault, but the resource itself 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 description notes that paywalls use these ids and that wallets can only be added in the dashboard, but it gives no explicit guidance on when an agent should call list_wallets versus other list tools. Usage is only indirectly 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?

The destructiveHint annotation already flags this as irreversible; the description reinforces that and goes further by naming the consequence ('the order is not delivered') and the authorization prerequisite. It adds meaningful context beyond the annotation, though it says nothing about side effects on related records or the response.

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

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

Two tight sentences: the action and its effect come first, followed immediately by the authorization condition and the irreversibility warning. 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 one-parameter destructive action with an existing annotation, no output schema, and no nested objects, the description covers the essentials an agent needs: what it does, when it is permitted, and that it cannot be undone.

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?

Single orderId parameter fully documented in the schema (100% coverage), so the schema carries the load. The description's 'payment on hold' framing implies the kind of order the ID must reference but adds no format or syntax detail. Baseline 3 applies.

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

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

States a specific verb (reject) and resource (payment) plus the precondition state ('on hold'), and the outcome clause ('the order is not delivered') makes it the clear counterpart to the sibling confirm_payment.

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

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

Explicitly gates invocation on creator approval ('Only do this after the creator has said so'), which is real when-to-use guidance. It stops short of naming the alternative path (confirm_payment) for the agent to weigh against, so it is clear context rather than full 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 provided, the description carries the full burden and does disclose the critical destructive trait: it replaces the paywall's settings, so omitted fields are lost. It also notes the credit cost of real payer verification, but says nothing about permissions, reversibility, or what is returned.

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 purpose, then the destructive replacement warning, then the mode-specific instruction. No filler or restatement of the 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 an 11-parameter mutation tool with no annotations and no output schema, the description covers the highest-risk facts (full replacement, pool workflow, credit cost). It omits error/permission behavior and the shape of the result, which an agent would otherwise have to discover.

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

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

Schema coverage is 100%, so the baseline is 3, and the description goes beyond it by tying codeMode 'unique' to the pool workflow and clarifying that 'same' mode pairs with accessCode semantics. It adds cross-tool meaning rather than repeating field text.

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

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

States a specific verb+resource pair — converting a link into a Gated link or updating its paywall — and immediately explains the consumer-facing outcome (pay to get the destination plus optional access code). This separates it from create_link and other link tools without needing 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?

Gives a concrete condition for the 'unique' codeMode and routes the agent to add_pool_items to fill the pool, which is real when-to-use guidance for the trickiest branch. It does not state when *not* to use it, nor prerequisites, so it stops 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?

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful context by saying it returns the account and credit balance, but it does not describe response fields, auth expectations, 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?

The description is a single compact sentence with no wasted text. It is front-loaded with the key returned resource, though the noun-phrase form is slightly terse for a tool description.

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

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

For a zero-parameter read-only tool, the description covers the main return concepts: account identity and credit balance. With no output schema, it could still say more about the response shape, but the low complexity limits the gap.

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

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

The tool takes zero parameters, so parameter semantics are inherently simple and the schema is complete. The description does not need to explain inputs beyond what the empty schema already conveys.

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

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

The description identifies a specific resource: the Xbitto account tied to the API key plus its credit balance. It lacks an explicit verb like 'Returns', but the title and sentence together make the tool's purpose clear and distinguish it from sibling list/get tools.

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

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

Usage is implied: an agent would call this to identify the current API-key account or check credits. However, the description gives no explicit when-to-use guidance, prerequisites, or comparison to sibling tools.

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