swop

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

Annotations already cover readOnly, openWorld, and non-destructive behavior. The description adds valuable context beyond annotations by warning that geo-restrictions apply in some regions, which explains why availability may differ per user. No contradiction with annotations.

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

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

Two sentences, each earning its place: the first states the core check and the key caveat; the second gives the actionable usage context. No redundant phrasing or 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 zero-parameter read-only availability check, the description conveys what the tool does, when to call it, and a key regional behavioral caveat. It does not specify the return format, but with no output schema and a nullary input, the description is sufficiently complete for an agent to use it correctly.

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

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

The tool has zero parameters and schema coverage is 100%, so the baseline is 4. The description does not need to explain parameters, and it adds no irrelevant parameter detail.

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 and resource: 'Check whether prediction-market trading is available.' It adds the geo-restriction nuance and distinguishes itself from sibling tools by noting that market DATA tools work everywhere, though it does not name a specific alternative like the strongest examples do.

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 explicitly says 'Call before suggesting trading actions,' giving a clear trigger condition. It also contrasts with market DATA tools by stating they work everywhere, implying data tools are the alternative when only data is needed, though it stops short of naming specific 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?

The description reveals important behavioral consequences beyond the annotations: the product becomes instantly purchasable by humans and AI agents over x402, and it is a live sellable entity. It also alerts the agent to confirm name/price with the user. This goes beyond the simple 'create' semantics and the false read-only/destructive flags.

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 with no fluff. The main action is front-loaded and the key behavioral consequence and user-confirmation requirement are included without repeating schema content.

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

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

For a create operation with six parameters, the description covers the essential context: what is created, where, what happens immediately, and the user-confirmation step. There is no output schema, so return-format details are not expected; the schema already handles parameter-level documentation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal new parameter detail beyond mentioning name and price, but the schema already documents all fields including defaults and constraints.

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

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

The description clearly states the verb 'Create', the object 'sellable product', and the target 'on the linked account's SmartSite'. This distinguishes it from read-only siblings like swop_get_store and the mutation sibling swop_update_my_smartsite.

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

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

The description gives clear context for when to use the tool: when the user wants a new sellable product on their SmartSite. It adds a key usage instruction—confirm name and price with the user before creating. It does not explicitly list when not to use it, but no competing create-product sibling exists.

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

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

Annotations already establish this is read-only, open-world, and non-destructive. The description adds meaningful behavioral detail: the tool returns current period, elapsed time, and closure state, and that it is authoritative over clock-based inference. This is sufficient context beyond the annotations.

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

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

Two sentences, front-loaded with what the tool does and what it returns, then a crisp usage rule. Every sentence earns its place with no redundant detail.

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

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

The tool is simple (one parameter) and annotated as safe/read-only. Since there is no output schema, the description covers the key return concepts: live status, period, elapsed time, and closed state. It could name exact response fields or units, but the semantic coverage is adequate 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 coverage is 100%; the 'slug' parameter is already described as an 'Event slug'. The description only adds the example '(e.g. a game)', which slightly refines semantics but does not carry substantial new meaning beyond the schema.

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

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

The description uses a specific verb ('Check whether') and clearly identifies the resource: live status of an event, including period, elapsed time, and closed state. It also distinguishes itself from sibling tools by emphasizing that live status should never be inferred from the clock, making its purpose unmistakable.

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

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

It gives explicit usage guidance: use this tool whenever live status is needed rather than inferring it from the clock. It does not explicitly list when-not-to-use or alternative tools, but the instruction 'use this' is strong and contextually clear.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is clear. The description adds behavioral context by disclosing that the tool returns all market variants for an event, including alternate lines and props or all outcomes, which is not visible from annotations. It stops short of describing response structure or pagination, but the core 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?

Two sentences carry all needed information: what the tool does, what result categories to expect, and when to call it. The most important action is front-loaded and there is no filler.

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

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

For a single-parameter tool with safe read-only annotations, the description is nearly complete: it names the input source, the return content categories, and the intended position in the workflow. It lacks a response/pagination note, and with no output schema that would be the only remaining gap for an agent invoking it correctly.

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

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

Schema coverage is 100%, and the schema description already tells the agent that slug is the 'Event slug from a market result (eventSlug field).' The prose only repeats 'by event slug' without adding new parameter semantics, 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 opens with a precise verb and object: 'Fetch every market for a single event by event slug,' which clearly separates it from broad search tools. It further specifies market composition (moneyline, alternate spread/total, props) and multi-outcome events, leaving no ambiguity about the tool's scope.

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

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

It gives explicit when-to-use guidance: 'Use after swop_search_markets when the user wants full detail on one game/event.' This establishes the intended sequence and scenario, though it does not spell out when not to use it or name other alternatives besides swop_search_markets.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the result is a point-in-time snapshot with a per-asset breakdown, which is useful, but it does not disclose additional traits such as data freshness or source.

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 concise sentence front-loads the core purpose and includes the key return details without any filler.

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

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

For a simple zero-parameter read-only tool with no output schema, the description is complete: it states what is returned, the scope of the data, and the point-in-time nature. Nothing needed for a correct call is missing.

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

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

The tool has no parameters and the schema covers 100% of them, so there is no parameter ambiguity to clarify. The zero-parameter baseline 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: returns the current wallet balance snapshot for the linked Swop account, including total USD and per-asset breakdown. This clearly differentiates it from sibling tools like get_my_orders or get_my_profile.

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

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

The description provides clear context: use this tool to retrieve the current balance snapshot for the linked account. It does not explicitly name alternatives or exclusions, but the read-only balance purpose is unambiguous among the sibling list.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by noting it covers both sales and purchases and reports payment, escrow/settlement, and fulfillment status, but it does not address return shape, pagination, or ordering 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 one tight sentence that front-loads the main purpose and packs in scope plus displayed statuses without any filler. Every clause contributes useful information, making it highly 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?

Given zero parameters, read-only annotations, and a simple retrieval purpose, the description is largely complete: it identifies the account scope and the types of orders and statuses shown. It could be slightly more explicit about return format or recency bounds, but this is minor for such a tool.

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

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

The input schema has zero parameters and 100% schema coverage, so the description carries little parameter burden. The mention of "recent" and "linked Swop account" adds some contextual meaning, but with no parameters to document, the baseline of 4 is appropriate.

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

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

The description clearly states the tool retrieves recent marketplace orders for the linked Swop account, covering both sales and purchases. It specifies the resource (orders) and useful scope (both directions), which is more specific than mere repetition of the title, though it does not explicitly contrast with 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?

Usage context is implied: this is for viewing account-specific orders, as opposed to market-wide tools like swop_get_orderbook or account tools like swop_get_my_balances. However, there is no explicit statement about when to use this tool versus alternatives, so an agent must infer the applicable scenario.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the meaningful context that the profile must be linked/connected and that it returns the current account's profile data, which is useful but not extensive.

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 tight sentence with no filler or redundancy. The key content (what account and what fields) is front-loaded, and the prerequisite is clearly appended.

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 profile retrieval tool, the description is largely complete: it names the resource, lists the returned fields, and states the connection requirement. The lack of an output schema is partially compensated by the field list, though behavior when no account is connected is left implicit.

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 description's mention of returned fields (name, email, SmartSites handle/bio) is output-oriented, not parameter-related, and adds no parameter semantics, but no parameters exist to document.

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

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

The description clearly identifies the resource (the linked Swop account) and the returned data (name, email, SmartSites), which matches the 'Get my profile' title. It is not a tautology and is distinguishable from identity-related siblings by the 'my' scoping, though it does not explicitly name any sibling.

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 the caller's own connected Swop profile and states a prerequisite ('Requires connecting your Swop account'). However, it provides no explicit guidance on when to choose this over alternatives like swop_lookup_identity or swop_search_identities.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: the orderbook is 'live,' contains bids/asks, and is scoped to a single outcome token. No contradiction with annotations.

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

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

Two sentences, no filler. The primary purpose is front-loaded, and the second sentence provides necessary sourcing guidance. Every phrase contributes information the agent needs.

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

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

For a single-parameter read-only tool with no output schema, the description covers the essential invocation details and the core return concept (bids/asks). It does not detail orderbook level structure, but the market-standard meaning is reasonably inferred.

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

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

The schema already documents tokenId as a CLOB token id, but the description adds meaning by specifying the token represents one outcome and, crucially, that the id comes from the clobTokenIds field of market results. This helps the agent source valid values 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 ('Fetch') and resource ('CLOB orderbook (bids/asks)') for one outcome token, clearly distinguishing it from price or quote siblings like swop_get_prices and swop_get_swap_quote. The scope is precise and immediately understandable.

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

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

The description gives a clear prerequisite for usage: token IDs come from the 'clobTokenIds field of market results.' This tells the agent when in the workflow this tool applies, though it does not explicitly name alternatives or exclusion conditions.

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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful scope around single-token historical candles, but does not mention pagination, rate limits, or output shape. No contradiction with annotations.

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

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

The description is two focused sentences with no filler. The first sentence states the core purpose, and the second efficiently explains the two non-obvious parameters.

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

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

For a simple read-only tool with full schema coverage and supporting annotations, the description is nearly sufficient. The main gap is that there is no output schema and the description does not explicitly define the shape of the returned candle series, though 'price series' and 'candle resolution' make it inferable.

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 parameters are already well documented. The description's explanation of interval and fidelity mostly restates the schema ('Candle resolution in minutes', window values), adding little new 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 clearly states the tool returns a 'Historical price series for one outcome token,' which identifies the specific verb, resource, and scope. This distinguishes it from sibling tools like get_prices or get_orderbook, which serve different data needs.

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 through 'Historical price series' that this tool is for historical candle data rather than current prices, but it never explicitly names alternatives or states when not to use it. The usage context is inferable but not directly 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?

Annotations already carry the read-only safety profile, and the description adds genuinely useful behavioral context beyond them: prices are book-derived, expressed as 0..1 probabilities, and may differ from cached market-row data. It doesn't describe behavior for invalid or unknown token ids, but the core behavior is well disclosed. No contradiction with the annotations.

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

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

Three sentences, front-loaded with the core action and batch constraint, followed by a targeted routing note. There is slight redundancy — 'live' appears in the title and twice in the description, and 'current best prices' overlaps with 'live book-derived prices' — but every sentence earns its place.

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

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

For a single-parameter, read-only batch fetch with no output schema, the description conveys the return semantics (book-derived 0..1 probabilities) and the freshness trade-off versus cached market rows. Minor gaps — the exact response mapping (tokenId → price) and error behavior for invalid ids — are low-stakes given the tool's simplicity and annotations.

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

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

Schema coverage is 100% — tokenIds is documented as 'CLOB token ids' with minItems/maxItems constraints — so the baseline applies and the description need not duplicate it. It adds modest meaning by reframing them as 'outcome token ids' and mirroring the 50-item batch limit. This meets the baseline but adds little 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?

States a specific verb-resource pair — batch-fetch current best prices for outcome token ids — with a concrete batch limit of 50. The contrast against the outcomePrices field on market rows differentiates it from market-retrieval siblings. The title reinforces the resource scope without ambiguity.

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 names the alternative (the outcomePrices field on market rows) and states the condition that selects this tool: when freshness matters, because cached market rows lag the book. It doesn't enumerate every price-related sibling (orderbook, price history), but the most likely confusion source is directly handled.

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

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

Annotations already establish read-only, non-destructive behavior. The description goes beyond by explaining exactly what state is reported—whether delegation is active, per-transaction and daily caps, and today's spent amount—which is relevant behavioral context for an agent.

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: the first front-loads what the tool returns, the second gives actionable usage guidance. No filler or 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?

With no parameters and no output schema, the description carries the burden of explaining the return payload and when to use the tool. It covers the active status, caps, and spent amount, and adds the 'before send' context, so an agent has everything needed to invoke it correctly.

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

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

The tool has zero parameters and the schema fully reflects that, so there is nothing for the description to add about inputs. The description instead focuses on the returned information, which is appropriate.

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

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

The description clearly identifies the resource—the linked account's transaction delegation for AI assistants—and the operation (getting it). It also lists the specific data returned, distinguishing it from sibling tools that fetch balances, orders, or profile info.

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 an explicit trigger: 'Check before attempting a send.' It stops short of naming alternative tools or saying when this tool should not be used, but the stated use case is clear.

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

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

Annotations already indicate a read-only, non-destructive operation, and the description adds valuable behavioral detail beyond that: returned buyUrls require a two-step HTTP 402 payment flow with a signed X-PAYMENT header, and user confirmation must precede payment. No contradiction exists with the readOnlyHint because the mutation happens via external GET requests, not through this tool.

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

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

The description is front-loaded with the core purpose, then provides the necessary purchase protocol and safety instruction. Every sentence adds essential information, and there is no fluff or repetition of schema 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?

Despite having no output schema, the description covers the returned data (products, USDC prices, x402 buyUrls), the non-obvious payment behavior, and the required user confirmation. For a single-parameter lookup tool, this is complete enough for an agent to call it and act on the result 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?

There is only one parameter and schema description coverage is 100%; the schema already provides the meaning and example for 'handle'. The tool description does not add meaningful parameter semantics beyond what the input schema contains.

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

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

The description opens with a precise verb and resource: 'List the real products a swop.id sells on their SmartSite.' It further distinguishes itself from payment-focused siblings by stating that the tool returns prices and x402 buyUrls, not payment execution itself.

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

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

The description makes the usage context clear: an agent should use this tool to retrieve a storefront's products and buyUrls, then follow the x402 flow to purchase. It does not explicitly name alternative tools to avoid, but it gives enough workflow context to guide correct use.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Read-only'. It adds valuable behavioral context beyond the annotations by explaining that the tool returns only an estimated output and does not execute the swap, instead directing the user to the Swop app. This is meaningful disclosure for a quote 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 dense sentences front-load the core purpose, then provide the essential EVM/Solana routing guidance and unit clarification. Every sentence earns its place, and there is no filler or repetition of annotation 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?

With no output schema, the description still tells the agent what to expect ('returns the estimated output') and that the user is directed to the app to complete the swap. Given the moderate complexity of dual-chain support and the fully documented parameters, this is sufficient context for correct tool selection and invocation. It could have added quote shape details, but they are not essential here.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description still adds value by mapping parameters to the two chain modes: 'pass chain plus token ADDRESSES' for EVM and 'omit chain and pass token MINTS' for Solana, and by clarifying that amounts use base units. This operational framing goes beyond the individual parameter descriptions.

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

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

The description states a specific action ('Get a swap quote') on a specific resource ('for the linked user') and immediately distinguishes the EVM and Solana variants by provider (LiFi vs Jupiter). This clearly separates it from sibling tools like get_prices or get_orderbook, so an agent knows exactly what this tool does.

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

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

The description gives clear, operational usage context: when to use EVM vs Solana, what to pass in each case, and that the tool is read-only and directs the user to complete the swap elsewhere. It does not explicitly name sibling alternatives or exclusion criteria, but the conditional guidance is strong enough for correct invocation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context that the data is canonical and intended as a reference mapping, but it does not go deeper into response format or structural behavior. Given the annotation coverage, this is adequate but not exceptional.

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 with no filler; the core purpose is front-loaded and the sibling reference is placed second. 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 zero-parameter, read-only taxonomy lookup, this description is complete: it says what the tool returns, what it should be used for, and which sibling to use for a different need. The lack of an output schema is not a gap because the mapping purpose is clearly stated.

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

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

There are zero parameters, so the description has no parameter-documentation burden. The schema is trivially complete at 100% coverage, and the description's statement about tag ids is contextual rather than necessary for parameter understanding.

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: it is the canonical mapping from sports/categories to tag ids. It also distinguishes itself from the likely sibling swop_get_taxonomy_stats, making the tool's unique function immediately 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?

It explicitly states the primary use case: obtaining tag_id values for swop_search_markets. It also points to swop_get_taxonomy_stats as the alternative when open volume or live-game counts are needed, giving an agent clear routing guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=true, destructiveHint=false), so the bar is lower. The description adds that the tool returns current/live-style aggregate counts ('open volume and live-event counts' and 'right now'), which is useful behavioral context. It does not disclose response limits, ordering, or whether the data is a live snapshot vs cached, but this is a minor gap given the annotation coverage.

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

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

The description is one tight sentence that puts the core output first ('Open volume and live-event counts per sport/category') and appends a single practical use case. There is no filler, repetition, or unneeded detail; it earns every word.

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 stats tool with no output schema, the description provides enough to know what is returned and roughly what it represents. It could be more explicit about the exact shape of the response or the definition of 'open volume,' but the low complexity and strong annotations make this a minor gap rather than a critical omission.

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

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

The tool has zero parameters and schema coverage is 100%, so the baseline is 4. The description confirms the output is pre-scoped to per-sport/category stats, meaning no parameter is needed for that axis. No additional parameter semantics are required.

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

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

The description clearly states the resource: open volume and live-event counts per sport/category, which goes beyond the title with a specific aggregation unit. It distinguishes itself from siblings like swop_get_taxonomy (taxonomy structure) by focusing on stats/volumes. It lacks an explicit verb like 'returns' or 'retrieves,' but the intent is unambiguous.

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

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

The phrase 'useful for "what is popular right now"' implies when the tool is appropriate, giving agents a clear use-case context. However, it does not explicitly state when not to use it or name alternatives such as swop_get_event_live_status or swop_search_markets for more granular stats, so usage guidance remains 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral context: case-insensitive exact matching and the set of returned fields. This goes beyond the annotations without contradicting them.

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 with no filler. The core behavior and output are front-loaded, and the alternative tool is mentioned without extra detail.

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

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

For a single-parameter, read-only lookup tool with a fully documented schema and clear sibling distinction, the description covers the essential behavior and return fields. No critical missing context for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, and the handle parameter is fully documented in the schema. The description reinforces the parameter with an example but does not add significant new semantic information 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?

The description clearly states the action ('Resolve'), the resource (an exact swop.id handle), and the result (profile details with display name, avatar, and wallet addresses). It also distinguishes itself from swop_search_identities by emphasizing exact match versus fuzzy search.

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

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

The description explicitly provides usage guidance: it is for exact matches and directs the agent to use swop_search_identities for fuzzy search. This gives clear when-to-use/alternative routing.

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

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

Annotations already mark this as destructive (destructiveHint=true), and the description adds meaningful context: the payment is executed from the linked wallet, it is constrained by caps, it is a two-step confirmation process, and it may return an approval link instead of executing. It does not detail reversibility or exact error conditions, but it goes beyond the annotation baseline.

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

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

Three compact sentences, front-loaded with the core action and then the two-step protocol and edge conditions. Every sentence contributes behavioral or usage information; there is no filler or repetition of the schema.

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

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

For a tool with destructive side effects and no output schema, the description covers the essential workflow, the preview fields returned, the confirmation flag, and the approval-link alternative. It could mention auth requirements or specific error payloads, but an agent has enough context to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining how url, confirm, and previewId interact: previewId comes from the initial call, confirm must be true only after user approval, and the url must be an HTTP 402 USDC challenge. This integrates the parameters into the workflow rather than just defining types.

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

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

The description clearly identifies the action as paying an external x402 payment link from the user's Swop wallet, with a specific resource type ('https URL that returns an HTTP 402 USDC challenge') and scope ('within their caps'). This distinguishes it from sibling tools like swop_send while also referencing swop_send as a behavioral model.

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 prescribes a two-step workflow: call without confirm to preview, show the user the preview, get explicit consent, then call again with previewId and confirm: true. It also states the fallback behavior for over-cap or no delegation (returns a Swop-app approval link), giving clear when-to-use and alternative-route guidance.

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

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

Annotations already mark destructiveHint true and readOnlyHint false; the description reinforces and enriches this by explaining the preview-before-execute pattern, cap enforcement, approval-link fallback, and liquidation risk. There is no contradiction with the annotations.

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

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

The description is dense but not bloated; each sentence adds workflow, cap, or risk context. The cap example and risk warning are useful, but the wording could be tightened slightly 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 complex 7-parameter mutation with no output schema, it covers caps, the two-step preview/confirm flow, error routing, and risk. It lists preview return fields, though it does not describe the shape of the final confirm response, which is the main remaining 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 100%, so the schema documents every parameter. The description adds meaning beyond the schema by explaining how margin and leverage interact ($25 at 5x controls ~$125), when confirm/previewId are required, and what reduceOnly does.

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 and resource: 'Open or close a Hyperliquid perpetual position for the linked user.' It also distinguishes itself from nearby tools by scoping to perps with Swop-app caps and by explicitly referencing the two-step flow of swop_send.

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 explicit workflow instructions: call without confirm to preview, show leverage/exposure, get confirmation, then call with previewId and confirm:true. It also explains reduceOnly for closing and the over-cap/no-delegation approval-link behavior, though it does not name alternative tools for excluded 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context—searching by handle/display name and returning public EVM/Solana addresses—but does not detail match semantics, ordering, or result limits beyond what the schema already provides.

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: the first defines the action and scope, the second lists return values and the intended use case. There is no filler, repetition of schema constraints, or unnecessary detail.

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

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

For a low-complexity, 2-parameter read-only search tool, the description covers the return values and the core use case. The only noticeable gap is not clarifying the relationship or difference from swop_lookup_identity, but that does not prevent a safe and 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 100: 'query' and 'limit' both have explicit descriptions explaining meaning and constraints. The tool description only reiterates 'handle or display name' and adds no additional format or behavior details, so the baseline 3 is appropriate.

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

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

The description states a specific verb ('Search') and resource ('Swop user identities (swop.ids)') and lists concrete return fields. It does not explicitly distinguish itself from the sibling tool swop_lookup_identity, 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?

It provides clear usage context: 'Use this to find a user or resolve a name to a wallet address.' However, it does not mention when to prefer alternatives like swop_lookup_identity, so it lacks explicit exclusions or when-not-to-use guidance.

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

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

Annotations already disclose readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: it names the exact return fields (question, slug, outcomes with prices, CLOB token ids, liquidity, end date) and clarifies that prices are 0..1 probabilities. This helps set expectations without contradicting the read-only 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?

Three dense sentences with no filler: purpose, search/filter capabilities, and return format are all front-loaded. Every sentence earns its place and the description remains skimmable for an agent.

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 present, the description correctly enumerates the returned fields and even specifies the probability scale, which an agent needs to interpret results. Parameter defaults like limit/offset are covered by the schema, and the read-only behavior is covered by annotations. The only notable gap is not explaining the default behavior when no query/filter is supplied, but this 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?

Schema description coverage is 100%, so the baseline is 3; the schema already documents every parameter. The description adds a bit of mapping by referring to 'live-game' (live) and 'sport filters' (tag_id), but it does not provide any deeper semantics beyond what the schema already gives. It neither harms nor substantially improves on 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 ('Search') and resource ('Swop prediction markets'), and adds 'by topic' plus 'Polymarket-backed' to establish scope. It further distinguishes itself from sibling market tools by enumerating free-text search over question/event/outcomes/tags and live-game/sport filters, which separates it from swop_get_event_markets and swop_get_prices.

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

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

The description implies usage context: topic-based search with optional live-game and sport filters. However, it never explicitly names alternatives or states when not to use this tool, leaving the agent to infer how it differs from swop_get_event_markets or swop_get_taxonomy. This is implied usage, not explicit routing.

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

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

Annotations mark destructiveHint: true, but the description adds critical behavioral context: the tool is two-step, returns a preview needing explicit confirmation, can return a Swop-app approval link instead of executing when over cap or confirm-only, and does not execute on the first call. This goes well beyond the annotations and materially changes how an agent should call it.

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: the first states the action and recipient, the second gives the precise two-step procedure, and the third adds a necessary safety warning. Every sentence contributes essential information 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 multi-step destructive tool with no output schema, the description sufficiently explains the full call lifecycle: preview, user confirmation, final execution, and edge cases such as over-cap and confirm-only settings. Nothing needed for correct invocation is missing.

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

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

Input schema already covers all parameters with descriptions, so the baseline is 3. The description adds value by explaining how confirm and previewId relate to the two-step flow, clarifying that amountUsd is sent as USDC, and noting caps behavior. This enriches parameter understanding 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 USDC (on Base) from the linked Swop wallet' to 'a swop.id handle or 0x address.' This clearly identifies the operation and its scope, and it is distinct from sibling tools like swop_get_swap_quote or swop_pay_x402_link.

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

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

The description provides explicit when and how instructions: call without confirm first, show the preview to the user, get explicit yes, then call again with previewId and confirm: true. It also states a firm negative rule: 'Never call with confirm before the user has seen the preview.' This is strong operational guidance.

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

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

Annotations already signal mutation (readOnlyHint=false) and non-destructiveness (destructiveHint=false). The description adds useful behavioral context: it targets the linked account's primary SmartSite by default and says only two fields are editable, clarifying limited impact.

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 terse sentences carry the action, target, default selection, and field limitation with no redundancy. 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 simple three-optional-param update with annotations covering the safety profile, the description is largely complete: it defines what is updated, on which SmartSite, and which fields. A small gap is that it does not explicitly require at least one of name or bio despite all params being optional in the schema.

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

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

Schema coverage is 100% and each parameter already has a clear description, so the baseline is 3. The description reinforces that name and bio are the editable fields and implies at least one may be provided, but it adds no syntax or format details 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 names a specific action (update), a specific resource (linked account's SmartSite), and the exact editable fields (display name and/or bio). It also distinguishes itself by narrowing scope to only these two fields, which is clear against the read/search-heavy sibling 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?

It states the applicable context: the linked account's primary SmartSite unless smartsiteId is given, and it explicitly restricts edits to name/bio. It does not name alternatives or provide a when-not-to-use rule, but no sibling performs a comparable SmartSite update, so the context is sufficient.

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