swop

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

Beyond the annotations, the description discloses important behavioral traits: the first call does not place the link, it returns a recommendation; the second call performs the placement; and the tool returns a viewUrl for previewing. This is meaningful context that annotations alone do not provide.

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

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

The description is well-structured with a clear 'TWO STEPS' organization that front-loads the critical workflow. Every sentence contributes necessary operational detail, and the preview types and optional overrides are summarized efficiently.

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 the tool has 7 parameters, no output schema, and a nontrivial two-phase flow, the description is exceptionally complete. It covers the first-call recommendation, the second-call placement, layout options, override fields, and the returned viewUrl, leaving no major operational gap for an agent.

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. The description adds workflow-level meaning by explaining when displayAs should be omitted versus set, how url is reused across both calls, and that overrides like title/buttonName/description/style apply to the infobar layout. This goes slightly beyond the schema's individual field 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 verb and resource: 'Add a link to the linked account's SmartSite'. It also clarifies the smart-placement behavior and two-step nature, making it easy to distinguish from siblings like swop_remove_link and 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 an explicit two-step usage protocol: call with just the URL to receive placement recommendations, then call again with displayAs to place the link. It also tells the agent to show previews and ask the user which layout they want. It does not explicitly name alternatives or exclusions, but the workflow guidance is strong.

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

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

Annotations already cover readOnly, 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?

Annotations already mark this as a write operation (readOnlyHint: false). The description adds valuable behavioral context beyond annotations: the product becomes instantly purchasable by humans and AI agents, and required fields are highlighted. 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?

Three sentences with no redundancy: purpose, effect, and required user confirmation are all front-loaded. Every sentence earns its place, and the structure is easy to scan.

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

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

For a 15-parameter tool with full schema descriptions and no output schema, the description covers the essential preconditions (user confirmation) and immediate effects (instant purchasability). It does not enumerate parameters, but the schema already handles that, so the description is sufficiently complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by instructing to confirm name and price with the user, a non-schema requirement that affects how those parameters should be handled. It also reiterates requiredness, but the confirmation guidance is the meaningful addition.

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 sellable product on the linked account's SmartSite.' Distinguishes itself from sibling tools like swop_update_product and swop_list_my_products by clearly indicating creation, and the added detail about instant purchasability clarifies the outcome.

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

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

Provides clear context on when to use: to create a new sellable product, and includes an explicit user-confirmation instruction for name and price. It does not explicitly contrast with alternatives, but the 'create' purpose and confirmation requirement give sufficient 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 only indicate mutation (readOnlyHint=false) and non-destructiveness (destructiveHint=false). The description adds useful behavioral context by explaining the effect: the product becomes visible to visitors and can be bought. This goes beyond the structured annotations, though it stops short of describing result/error behavior.

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

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

The description is short, front-loaded with the main action, and clearly communicates the required sequence. There is minor redundancy in mentioning swop_create_product multiple times, but no wasted sentences.

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

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

For a simple mutation tool with 3 parameters, the description covers the main action, prerequisite, and key parameter. With no output schema, it does not describe the return value or confirmation behavior, but this is a minor gap given the low complexity of the 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 schema already documents templateId, smartsiteId, and carouselTitle with meaningful descriptions. The description reinforces that templateId comes from swop_create_product, 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?

The description states a specific verb and resource: putting an already-created product onto the SmartSite as a visible, purchasable product tile. It clearly differentiates this from sibling tools like swop_create_product by emphasizing that the product must already exist.

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 identifies the prerequisite tool and sequence: 'Use swop_create_product first to make the product, then this to display it.' This gives an agent unambiguous guidance on when to call this tool versus the related creation tool.

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 mark readOnlyHint=true and destructiveHint=false; the description adds useful context by stating it returns a current snapshot and that returned item ids can be used for removal, plus the workflow warning that calling it first keeps edits additive. It does not provide deep behavioral details like pagination/rate limits, but for a simple read tool the combination is strong.

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 action, uses a compact list to convey return contents, and closes with the one usage rule that matters. Every sentence carries operational value; 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 simple read-only getter with no output schema and one optional parameter, the description is nearly complete: it names the main returned fields, flags removal ids, and explains the prefetch purpose. A small gap is that it doesn't describe the output shape or whether the result includes any account-level/workspace distinctions, but this is minor at this complexity.

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

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

The schema fully documents the only optional parameter ('Specific SmartSite id (default: primary)'), so the baseline is 3. The description does not add much about the parameter itself beyond implying the linked account's default/primary SmartSite is retrieved, so no extra semantic lift is provided.

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

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

The description names a specific verb ('Get'), a concrete resource ('the linked account's current SmartSite'), and enumerates what is returned (bio, appearance, links with item ids, product tiles, viewUrl). It clearly positions the tool as the read-before-edit counterpart to swop_update_my_smartsite and the add/remove link tools, so an agent can distinguish it from siblings without opening schemas.

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 states when to invoke it: 'ALWAYS call this before adding or changing things so edits stay additive.' It gives a strong trigger for use, but it does not name alternative tools or state conditions when this tool should not be used, falling just short of full 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 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 indicate read-only and non-destructive behavior. The description adds meaningful behavioral detail beyond annotations, explaining how the same link behaves differently for humans versus AI agents and that agents are routed to an x402 challenge.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no filler. The example of sharing in chat, post, or message earns its place by clarifying the exact use case.

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 two clearly documented parameters, no output schema, and a read-only annotation set, the description provides enough context to invoke the tool correctly. It clearly implies the returned artifact is a shareable link and explains how the link behaves for the two audiences.

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 parameters handle and sku are already fully documented in the input schema. The description does not add additional param-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Get one shareable link for a product.' It also distinguishes the tool by explaining the link's dual behavior: humans see a product page with a Buy button, while AI agents receive the x402 payment challenge.

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 explicit usage context: 'Use this to share a product in chat, a post, or a message.' It does not name alternatives or state when not to use the tool, but the intended scenario 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 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, so the description does not need to repeat safety. It adds value by specifying the output fields (id, name, price, inventory, status), which is useful behavioral context. It does not mention any edge cases like pagination, but for a list tool with no parameters, that is acceptable. 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 sentences with zero fluff. The first sentence states the action and output, the second explains follow-up use of the returned id. Information is front-loaded and every sentence earns its place. No redundancy 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?

Given that the tool has no parameters, no output schema, and annotations that already cover safety, the description fully explains what the tool does and how to use the result. It even names the two sibling tools that the returned id will be used with. An agent can call this tool correctly and understand the next steps without additional information. Nothing essential 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 input schema is empty (0 parameters), so there are no parameter semantics to clarify. Baseline for 0 params is 4. The description adds context about the output for each product, which is not strictly parameter-related but still helpful. It could have mentioned that no parameters are needed, but that is already clear from the schema, so it does not need to be repeated.

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

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

The description states a specific verb ('list'), a clear resource ('the linked account's products'), and enumerates the fields returned (id, name, price, inventory, status). It also references sibling tools (swop_update_product, swop_feature_product) in a way that distinguishes this tool as the read/list step. This is clear and specific.

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 tells the agent that after listing, the id should be used with swop_update_product (to edit/unlist) or swop_feature_product (to show on SmartSite). This gives clear when-to-use guidance for the follow-up actions. However, it does not explicitly contrast with other list-like tools such as swop_get_my_orders or swop_get_store, so it leaves some room for ambiguity in broader selection, though the context is strong enough to score above baseline.

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. The description adds valuable behavioral context beyond annotations: results include live balances, Merchant Bucks are store credit with a specific flag and decimal precision, and an empty list is a valid outcome rather than an error. This materially helps the agent interpret results correctly.

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

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

The description is three sentences, front-loaded with the core operation and scope, and every sentence contributes: what is listed, the important store-credit caveat, and the empty-list interpretation. No filler or redundancy.

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

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

For a zero-parameter read-only list tool with no output schema, the description covers the essential operational facts: scope, live balances, the store-credit warning that prevents misuse, and empty-list semantics. Nothing critical an agent needs to call or interpret the tool correctly is missing.

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

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

There are zero parameters, so the baseline is 4. The description provides context about the implicit scope ('the linked account has launched on Base'), which is useful, but there are no parameter definitions to add meaning to since the schema is empty.

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

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

The description states a specific verb (list), a specific resource (community tokens and merchant Bucks the linked account has launched on Base), and the output characteristic (live balances). It clearly distinguishes from sibling tools like swop_list_my_products and swop_get_my_balances, even without naming them.

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

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

The description implies the tool is for inspecting launched tokens on Base and emphasizes that it is read-only, but it does not explicitly state when to use this tool versus alternatives such as swop_list_my_products or swop_get_my_balances. No exclusions or alternative guidance are provided, so usage context is mostly inferred.

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

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

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 mark this as destructive (destructiveHint=true), and the description reinforces this by saying 'Remove' and 'Confirm with the user first.' It adds useful behavioral context about sourcing the parameters from swop_get_my_smartsite, which is beyond what the annotations convey.

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 focused sentences deliver the core action, the item categories, the parameter sourcing workflow, and the user-confirmation requirement. There is no filler or repetition of already-available schema 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 destructive removal tool with strong annotations and full schema coverage, the description provides everything an agent needs: what to remove, how to identify the target, the exact source of identifiers, and the required user confirmation. No output schema is needed for a removal action.

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?

Although schema coverage is 100%, the description adds meaning by explaining the relationship between itemId and contentType and how to obtain them from swop_get_my_smartsite. The mapping from contentType enum values to real-world item categories provides semantic value beyond raw enum names.

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 precise verb ('Remove') and clearly defines the resource: links/icons/info-bars/product tiles from the SmartSite. It distinguishes itself from siblings like swop_add_link by focusing on the removal use case and enumerating the exact item categories.

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 explicit how-to guidance: obtain the item's id and contentType from swop_get_my_smartsite, including a mapping from human-friendly categories to contentType enum values. It also instructs the agent to confirm with the user first, which is critical for a destructive operation.

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 indicate destructive and non-read-only behavior, and the description fully aligns by describing an on-chain execution. It adds substantial behavioral context beyond annotations: gas is sponsored, token approvals are automatic, over-cap returns an approval link, and a mandatory two-step confirmation with explicit user consent is required.

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

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

The description is dense but every sentence carries essential information: scope, network restriction, two-step protocol, user confirmation requirement, gas/approval behavior, and unit/address conventions. It is suitably front-loaded and avoids filler.

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

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

Given the tool's complexity, the description covers all critical operational aspects: when to use it, how to sequence preview and confirm calls, what counts as confirmation, unit semantics, and failure behavior. No output schema exists, so the description appropriately focuses on invocation behavior rather than return types.

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 baseline is 3, but the description adds meaningful extra guidance: amounts must be in base units, tokens are specified by EVM contract addresses, and previewId/confirm are tied to the preview step. This clarifies how to construct the two-step call beyond the schema's field 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 clearly states the specific action: executing an EVM token swap from the user's Swop wallet, within delegation caps. It also distinguishes itself from alternatives by noting 'EVM only (via LiFi); Solana swaps still complete in the app.' This is precise and differentiates from sibling tools like 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?

The description gives explicit when-to-use guidance: EVM swaps only, while Solana swaps are excluded and handled in the app. It also provides a detailed step-by-step workflow: call without confirm to preview, show results to the user, obtain explicit yes, then call again with previewId and confirm:true. It even covers the over-cap/no-delegation fallback with an approval link.

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 it's a write operation (readOnlyHint false) but not destructive (destructiveHint false). The description adds the partial-update behavior ('pass only what you want to change') and that backgroundGradient 'clears the solid color' (though that is also in the schema). It provides useful context beyond generic annotations without contradiction.

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 well-structured sentences, front-loaded with the core purpose and followed by routing guidance. No wasted words; 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?

Given 10 optional parameters with full schema descriptions and no output schema, the description covers the overall scope and usage clearly. It could mention return behavior or error scenarios, but for a partial-update tool with clear schemas, it is sufficiently complete.

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

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

Schema has 100% parameter descriptions, so baseline is 3. The description lists the parameter categories but does not add new semantics beyond the schema's existing per-field descriptions. It repeats what the schema already says, so it adds no extra value here.

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

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

The description clearly states the tool edits the linked account's SmartSite and explicitly lists the fields (name, bio, background, theme, font, header layout). It distinguishes from siblings by naming alternatives for adding links and products, so an agent knows exactly what this tool does and does not 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 states when NOT to use this tool: for links/buttons/info bars use swop_add_link, for products use swop_create_product / swop_feature_product. It also instructs to 'pass only what you want to change', giving clear usage intent. This is excellent routing guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description aligns with those flags. It adds useful behavioral nuance: edits are partial, unlisting is done via status='archived', and user confirmation is required for name/price changes. It does not detail side effects beyond those, but the annotation lowers that burden.

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 tight sentences with no filler. It front-loads the core edit/unlist purpose, then gives the essential operational rules, and every sentence contributes a distinct fact an 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 15-parameter mutation tool, the description covers the key orchestration rules: partial updates, provenance of productId, unlisting behavior, and confirmation requirements. The schema fully describes each parameter. The only notable gap is the absence of return/error behavior, which matters more because there is no output 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 description coverage is 100%, so the schema already handles individual parameter meanings. The description adds value with patch semantics ('ONLY the fields to change'), clarifies unlisting through status, and flags name/price changes as requiring user confirmation, which is not apparent from the schema alone.

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 ('Edit') and the resource ('one of the linked account's products'), and additionally covers the unlist behavior. This distinguishes it from sibling tools like swop_create_product and swop_list_my_products without relying on the title alone.

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

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

It gives concrete usage instructions: pass productId, send only the fields to change, leave omitted fields unchanged, and set status to 'archived' to unlist. It also instructs the agent to confirm price and name changes with the user first. It does not explicitly contrast with create/feature alternatives, 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.