Cofferline

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

No annotations are provided, so the description carries the burden. It discloses that the action is canceling (destructive) and requires authentication, which is helpful. However, it doesn't mention reversibility, return value, or any side effects beyond the cancellation itself, leaving some behavioral uncertainty.

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

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

The description is two short sentences, front-loaded with the core action and scope. Every word is purposeful, with no redundant or filler content.

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

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

The tool is simple: cancel all resting orders with an optional market filter. The description covers purpose, scope, and authentication, and the schema handles parameter details. While no return value is described, it's not critical for this straightforward destructive operation, making the description 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% with clear descriptions for both parameters. The description adds little beyond restating 'credential' and 'market' in a sentence. It does not introduce format, constraints, or defaults not already in the schema, 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 clearly states the action ('Cancel every resting order') and scope ('for the credential, optionally within one market'). It distinguishes from sibling tool cancel_pm_order by using 'every' and 'resting', making it unambiguous.

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

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

The description clearly implies when to use this tool: when canceling all resting orders for a credential, possibly filtered by market. It doesn't explicitly name alternatives or exclusions, but the scope and verb make the intended use clear relative to siblings like cancel_pm_order.

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

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

With no annotations provided, the description must cover behavioral aspects. It discloses the auth requirement and the operational window, which are important. However, it does not describe side effects (e.g., whether cancellation is reversible), error conditions (e.g., what happens if the intent already executed), or the response shape. This is adequate for a simple cancel operation but not rich.

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

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

The description is a single sentence that front-loads the core action ('Cancel a planned intent') and packs essential context (timing and auth) with zero wasted words. It is efficient and easy to parse.

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 simplicity (single parameter, no output schema), the description covers the key operational context: the cancellation window and auth requirement. It does not elaborate on edge cases or return values, but for a straightforward cancel operation, this is reasonably complete. A full description might mention what happens on failure, but the current text is sufficient for an agent to understand the tool's purpose and prerequisite.

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 description already fully covers the parameter 'id' (intent id uuid), achieving 100% coverage. The description does not add further semantic details about the parameter beyond that, 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 clearly states the verb 'Cancel' and the resource 'planned intent', distinguishing it from sibling tools like list_intents or create_intent. It also adds context about the timing window ('a few-second window before execution claims it'), which directly clarifies the tool's specific role.

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

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

The description notes the timing window ('before execution claims it') which implies when to use it, and mentions 'Auth required' as a prerequisite. However, it does not explicitly state when not to use it or mention any alternative tools (e.g., a force-cancel or revert), so guidance is clear but not fully elaborated.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It only notes that authentication is required, but fails to mention what happens after cancellation (e.g., success/failure returns, irreversibility, or potential idempotency). The description is too sparse for a mutation 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 a single, focused sentence with no superfluous words. It gets straight to the point ('Cancel one resting prediction-market order. Auth required.') and is appropriately front-loaded.

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

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

For a simple cancellation tool with only three parameters, the description is functional but not fully complete. It lacks any mention of return values, error cases (e.g., order already filled), or whether the operation is idempotent. Given the absence of an output schema, slightly more detail would improve completeness.

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

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

The schema provides 100% coverage for all three parameters with descriptive text, so the description does not need to add further semantic detail. It correctly adds nothing beyond what the schema already conveys, meeting the baseline for high schema coverage.

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 ('Cancel') with a precise resource ('one resting prediction-market order'), which clearly distinguishes it from cancel_all_pm_orders. It unambiguously states the action and 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?

The description implies single-order cancellation via the word 'one,' but it does not explicitly state when to use this tool over alternatives like cancel_all_pm_orders or cancel_intent. It also does not provide exclusions or context for when cancellation might not be appropriate.

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

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

No annotations are provided, so the description carries the transparency burden. It explicitly notes auth is required and frames the operation as a non-mutating 'check' rather than an order submission, strongly implying no side effects. It doesn't describe exact response shape, but the pre-flight framing is behaviorally clear.

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

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

A single, front-loaded sentence that states the action, resource, purpose, and auth requirement with zero redundancy. Every word earns its place.

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

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

For a simple policy check with full schema coverage, the description adequately conveys the purpose, auth requirement, and pre-flight nature. It doesn't explicitly state return format or how the optional state object is used, but the schema covers state and the 'allowed right now' wording implies a yes/no decision.

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 little parameter-level meaning beyond what the schema already documents; 'cost' and 'right now' loosely map to cost_usd and state, but no new semantic detail 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?

Description names a specific action (pre-flight policy check), a specific resource (prediction-market order), and the evaluation criterion ('would this cost be allowed right now?'). This clearly distinguishes it from order-creation siblings like create_pm_order and prepare_pm_order.

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 'pre-flight' wording gives explicit when-to-use context: before placing an order, check whether the cost would be allowed under current policy. It does not name alternative tools, but the usage context is clear and no misleading guidance is present.

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

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

With no annotations provided, the description carries full burden. It discloses this is a non-mutating policy check ('would this spend be allowed'), which is useful. However, it doesn't disclose auth method details, whether it checks live policy vs. simulated, or any side effects of the check. Adequate but not rich.

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

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

Two sentences, highly scannable, front-loaded with critical info. The 'Auth required' is a useful note, and the rhetorical question format is efficient. Zero wasted words.

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

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

For a read-only pre-flight check with 100% schema coverage, the description is sufficient. It explains what the tool does, infers non-mutation, and the 'Auth required' hints at permission context. A small gap is not detailing what the response contains, but it's not critical for a check 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%, so all parameters are documented. The description itself adds little param-specific detail beyond schema, but the baseline of 3 applies since schema covers everything.

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?

Description uses specific verb 'check' with clear resource 'spend' and includes helpful context ('Pre-flight policy check'). Clearly distinguishes from siblings like check_pm_order by focusing on policy check for spend under wallet policy.

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?

Description implies usage as a pre-flight validation step, and the 'Auth required' note gives context. While it doesn't explicitly name alternatives, the pre-flight framing makes when-to-use clear. Slight deduction for not explicitly excluding when to not 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that the tool is 'Free, no auth' and that it produces a session token for subsequent authenticated calls. It does not mention token expiry or invalidation of prior sessions, but for a login completion step this is reasonably 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, front-loaded with the verb phrase, and no filler. Every clause adds value: the action, the output, the token usage, and the cost/auth status.

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

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

For a two-parameter, no-output-schema tool, the description fully covers the workflow: it explains the input origin, the output token, and how to use the result. No significant information gap remains.

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 describes both parameters accurately and completely (100% coverage), so the baseline is 3. The description mentions the 'signed SIWE message' but adds little about the signature parameter beyond what the schema 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 opens with 'Finish wallet sign-in' and immediately specifies the action: 'exchanges the signed SIWE message for a cl_sess_… session token'. This clearly distinguishes the tool from its sibling start_siwe_login, which initiates the sign-in flow.

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

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

The description implies when to use it ('Finish wallet sign-in') and gives post-use guidance ('use it as the Authorization bearer on every authenticated tool'). It does not explicitly name alternatives or state when not to use, but the reference to a signed SIWE message makes the prerequisite and context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Auth required' and implies a state change, but it omits side effects, reversibility, whether the prepared state is consumed, and failure/response behavior. This is a thin behavioral disclosure for a mutating operation.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes: the action, the target state, the required signature, and the auth requirement.

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 state-changing tool with no annotations and no output schema, the description covers the core action and auth requirement but leaves out explicit prerequisite details (that the delegation must already be in prepared state) and postconditions. It is minimally viable but not fully 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 the baseline is 3. The description adds some useful context by calling the digest the 'enable digest' and emphasizing the 'prepared delegation' state, but it does not materially clarify id, owner, or enable_sig beyond what the schema already documents.

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

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

Description uses a specific verb ('Activate') with a clear resource ('prepared delegation') and a precise mechanism ('owner's signature over its enable digest'). This clearly distinguishes it from sibling tools like prepare_delegation, renew_delegation, and revoke_delegation.

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 'prepared delegation' clearly implies this is used after prepare_delegation, and the requirement of the owner's signature gives concrete usage context. It does not explicitly name alternatives or exclusions, so it stops short of the top score.

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

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

With no annotations, the description carries the transparency burden. It notes 'Auth required' and mentions the executor pipeline planning and filling, which gives some behavioral insight. However, it does not disclose side effects, idempotency, error conditions, or whether the operation is synchronous or asynchronous.

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 concise, consisting of two clear sentences with no redundant text. It efficiently conveys the core purpose and a key behavioral note (auth) without unnecessary elaboration.

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

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

The description lacks essential context such as return values (since there is no output schema), error handling, or any details about what happens after the intent is created. It does not explain the 'executor pipeline' outcome or provide enough information for an agent to fully anticipate the tool's behavior.

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

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

The schema covers 86% of parameters with descriptions, and the description adds limited extra meaning by naming 'conversion' and 'gas_topup' which align with the kind enum. It does not elaborate on how parameters interact or any additional constraints beyond what the schema already states.

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

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

The description clearly states the tool's function: 'Create a conversion or gas_topup intent.' It names the two specific intent kinds and adds context about the executor pipeline, making it distinct from other create operations like create_pm_order or prepare_delegation.

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 no explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it or suggest alternative tools for different scenarios. The phrase 'under policy' hints at a constraint but lacks specific usage criteria.

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

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

With no annotations provided, the description must disclose behavioral traits. It states that orders are signed server-side with a stored credential and that auth is required, which provides some context. However, it omits potential side effects like irreversible order placement, fee implications, or policy enforcement specifics.

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

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

Two sentences, front-loaded with the core action and policy context. The second sentence efficiently enumerates key parameters without redundancy. No wasted words.

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

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

Although there is no output schema, the tool is a create operation with 10 parameters. The description covers the main purpose and key parameters but omits the `state` and `client_order_id` semantics. Given the schema descriptions are thorough, the description is adequate but not exhaustive, leaving room for the agent to infer defaults and optional fields.

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 90%, so baseline is 3. The description adds value by highlighting Polymarket-specific fields and giving a concrete example of the price format ('0.55'). It also lists the essential parameters in sequence, which helps the agent understand the minimum required fields 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 clearly states the tool places a prediction-market limit order, with specific details about server-side signing and policy constraints. It distinguishes from sibling tools like prepare_pm_order and submit_pm_order by mentioning the 'under policy' and server-side signing aspects, though it doesn't explicitly contrast with 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?

No guidance is given on when to use this tool versus alternatives like submit_pm_order or prepare_pm_order. It mentions 'under policy' but doesn't explain the intended flow (e.g., prepare then submit) or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It only states that authentication is required; it does not disclose what data is included, whether it is a costly/long operation, or any side effects (e.g., rate limits, data format). For an export tool, this leaves significant ambiguity.

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

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

The description is two short sentences, front-loaded with the core action. It conveys the essential purpose without verbose filler, and every word 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 that there is no output schema and the operation exports the entire account's data, the description should explain what 'data' includes, the output format, potential size or time implications, and any side effects. It mentions only auth and export, leaving the agent with insufficient context for safe/effective invocation.

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

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

The tool has zero parameters)SkipSchema coverage is 100% (vacuously, since there are no params). With no parameters to explain, the baseline of 4 applies; the description adds no param info but also needs none.

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: 'Export all of this account's data in one document.' It specifies the verb (export), the resource (account's data), and the deliverable (one document). This distinguishes it from siblings like get_statement or list_* tools, which are narrower or different operations.

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

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

The description gives a single precondition: 'Auth required.' It provides no guidance on when to use this tool versus alternatives, no mention of limitations or whether it is for bulk export vs. specific queries. With no sibling differentiation or exclusions, usage context is minimal.

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

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

With no annotations, the description carries full responsibility for exposing behavioral traits. It discloses that authentication is required and that the tool reports how many pre-signed authorizations remain, but it does not explicitly state that it is read-only or whether viewing the rule consumes authorizations. This leaves ambiguity about potential side effects.

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 concise sentences with no filler. It front-loads the resource and includes a separate note about authentication. Every word serves a purpose.

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 getter with no output schema, the description provides the key information: what it returns and that auth is needed. It is sufficient for invoking the tool, though it could enrich the context by explaining what 'auto-topup rule' means or describing the response format, but this is not critical given the tool's simplicity.

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

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

The tool has zero parameters, so the schema is completely covered by default. The description adds no parameter-specific meaning, but none is needed. The baseline of 4 for zero parameters 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 clearly identifies the resource (auto-topup rule and remaining pre-signed authorizations) and implies a retrieval operation, but uses a noun phrase ('The auto-topup rule...') rather than an explicit verb like 'Gets' or 'Fetches.' It does not distinguish from siblings like set_auto_topup, but the tool name and context make the purpose 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?

The only usage-related information is 'Auth required,' which is a prerequisite rather than guidance on when to use this tool versus alternatives. There is no mention of when to call get_auto_topup instead of set_auto_topup or remove_auto_topup, or what scenarios benefit from checking the rule and authorization count.

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

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

With no annotations present, the description must fully disclose behavioral traits. It notes 'Auth required,' which is a meaningful behavioral constraint, and explains the balance calculation. However, it omits other traits that could be relevant, such as read-only nature, potential latency, and what happens on insufficient permissions. It's adequate but not rich in disclosure.

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

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

The description is exceptionally concise: two short sentences, each earning its place. The first sentence defines the resource with a clear formula, and the second highlights authentication. No fluff, front-loaded with the most important 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?

Given the absence of an output schema, the description should have explained what the response contains (e.g., a numeric balance, currency, decimal places). It does not. The tool is simple enough that the omission might be acceptable, but from a completeness standpoint, knowing the return format would be essential for programmatic use. At minimum, it falls short of fully documenting a zero-parameter call.

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

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

The tool has zero parameters, so schema coverage is 100% (vacuously). The rubric prescribes a baseline of 4 for zero parameters, and the description does not need to compensate for missing parameter details. There are no undocumented parameters to worry about.

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 the prepaid fee balance, defined precisely as 'settled credits minus fee debits.' This specific verb-resource pairing unambiguously distinguishes it from other tools like check_spend or topup_balance, which could otherwise be confused for balance-related operations.

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

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

The description provides no guidance on when to use this tool versus alternatives like check_spend, get_me, or list_tokens. It neither mentions scenarios where this tool is appropriate nor excludes cases better served by siblings. The only hint is the formula, which implies a financial balance context, but no explicit or even implicit when-to-use advice is given.

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

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

With no annotations, the description carries the full burden and does well by disclosing that the data comes from real completed intents only and that the tool is free and requires no authentication. It does not describe return format or potential empty results, but for a simple no-parameter read-only tool, this is sufficient.

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

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

The description is two short sentences, front-loaded with the core purpose and followed by access details. Every word adds value, with 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 the tool's low complexity (no parameters, no output schema), the description adequately covers what the tool returns, the data source, and access requirements. It could specify the exact response shape, but the core information is complete enough for an agent to decide to call it.

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

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

The tool has zero parameters, so the baseline is 4. The description adds useful context about the output dimensions (USD size bucket) even though no parameter documentation is needed.

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 tool's purpose: returning measured execution benchmarks with a specific metric (median savings vs arrival quote) and segmentation (USD size bucket). It distinguishes itself from siblings like get_quotes by emphasizing real completed intents, though it does not explicitly name alternatives.

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

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

The description implies usage: call this tool to obtain actual execution benchmark data rather than quotes or intents. It also notes 'Free, no auth,' which is useful access guidance. However, it does not explicitly state when to prefer this tool over siblings or mention any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions 'Auth required,' which is a minimal requirement, but does not disclose whether the operation is read-only, what happens if the delegation is not found, or any other side effects or constraints. This is insufficient for a tool without annotation support.

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 exceptionally concise, consisting of two short sentences: 'Fetch one delegation. Auth required.' Every word serves a purpose, and the main intent is front-loaded immediately. No redundancy or fluff.

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 getter with one parameter and no output schema, the description is somewhat complete but lacks details on the return value or error behavior. It does not mention what the response contains (e.g., full delegation object) or how failures are handled, which could be useful in the absence of an output schema. The description meets minimal viability but has gaps.

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

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

The schema fully documents the only parameter 'id' with 100% coverage, so the description adds no additional information about parameters. The description does not elaborate on the format or usage of the id beyond what the schema already states, so a 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 clearly states 'Fetch one delegation' using a specific verb (fetch) and resource (delegation), and the qualifier 'one' distinguishes it from the sibling tool 'list_delegations' which fetches multiple. Purpose is unambiguous and distinct from other delegation-related tools.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like list_delegations or other delegation tools. However, the presence of a required 'id' parameter implies usage for retrieving a specific delegation by identifier, so usage is implied but not explicitly discussed.

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?

Mentions auth requirement and that fills/report are included once filled, but lacks details on side effects, errors, or further behavioral nuances. Without annotations, this is minimal but adequate for a simple fetch.

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

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

Two concise sentences with no redundant information, directly conveying the essential purpose and key 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 straightforward getter with one parameter and no output schema, the description covers the core return contents (fills, post-trade report) and auth, though it omits edge cases like not-found scenarios. Overall adequate for its simplicity.

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 only parameter 'id' is described identically in both schema and description, providing no additional context beyond the schema, keeping the baseline score.

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

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

The description clearly states the tool fetches a specific intent by ID, including fills and post-trade report, distinguishing it from list_intents and other intent operations.

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

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

It implies usage for retrieving a single intent when an ID is available, but does not explicitly contrast with alternatives like list_intents or specify when not to use it.

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

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

With no annotations provided, the description carries the full disclosure burden. It explicitly states the operation is an identification/read action, lists the returned data (address, kind, scopes), and warns that auth is required. It does not describe failure behavior, but for a zero-parameter identity tool this is sufficient.

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 sentence with one list and one prerequisite, no filler or repetition. It is front-loaded as expected and every word contributes meaning.

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

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

For a zero-parameter, no-output-schema identity lookup, the description is complete: it names the purpose, the specific return fields, and the authentication requirement. There are no gaps that would prevent an agent from selecting and 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?

The tool has zero parameters, so the input schema is complete and there is nothing for the description to add. The baseline of 4 applies because no parameter documentation is needed.

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 names the verb 'Identify' and target resource 'the authenticated account', listing the returned aspects (address, kind, scopes). This distinguishes it from sibling getters like get_balance or get_policy, which target different resources.

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

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

The statement 'Identify the authenticated account' implies it is the tool to call for current user/identity context, and 'Auth required' states a necessary precondition. It does not explicitly name alternatives or exclusions, but the context is clear enough for a simple identity lookup.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that the actual execution must happen outside MCP ('executed outside MCP — this server cannot sign'), which conveys a read-only nature and a critical limitation. However, it does not explicitly state that it does not modify state or mention any side effects, but the 'cancel sign' statement strongly implies no writes. This is valuable context beyond the minimal schema.

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

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

The description is a single concise sentence that front-loads the core purpose, then adds a critical caveat about execution. Every word serves a purpose; no filler or redundancy. It is efficient while still informative.

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 (1 parameter, no output schema), and the description covers both the core functionality and the important limitation (cannot sign, executed externally). It also notes the auth requirement. It is complete for the tool's complexity, though it could mention what a typical use case is for the returned calldata, but this is a minor 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 description coverage is 100% for the single parameter 'address' with its own description. The tool description adds no further parameter semantics, so it leverages the schema as the primary source. This meets the baseline for when the schema covers everything, but the description does not go beyond the schema's clarity.

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's function: 'Polymarket trade-readiness for an address' with specific details on the output (live approval status plus calldata). It includes a technical caveat about execution being outside MCP, distinguishing it from other tool variants. This is a specific verb-resource combination that sets it apart from siblings like get_balance or check_pm_order.

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 use case (checking trade-readiness) and notes the authentication requirement, but it does not explicitly state when to use this tool versus alternatives or provide any when-not guidance. The purpose is clear, but no explicit exclusions or comparisons to sibling tools are given.

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

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

No annotations; description states the tool only creates calldata and cannot sign, and mentions auth requirement, which is transparent about its limitations and 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?

Description is brief and to the point, with no unnecessary words.

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

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

Explains the purpose, the execution context, and auth; without output schema, it conveys that it returns calldata. Adequate for a generation tool, though could specify return format.

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

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

Schema already provides descriptions for both parameters (id and new_owner); description adds no additional nuance, so baseline of 3.

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

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

Clearly states it generates calldata for swapping the funder Safe's owner to a new EOA, distinguishing it from other tools like prepare_delegation or prepare_pm_order.

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?

Mentions that the owner executes it outside MCP and server cannot sign, implying when to use it (to generate calldata for owner swap). However, it does not explicitly contrast with alternatives or state prerequisites.

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

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

With no annotations, the description carries the transparency burden. It discloses auth requirement and ordering behavior, but lacks details on error handling, pagination, or side effects (which are minimal for a read operation). It does not contradict 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?

A single concise sentence that front-loads the core purpose and key behavioral facts with no wasted words.

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

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

For a simple list tool with no output schema and two optional params, the description covers essential behavior (ordering, active flag, auth). It omits potential pagination or default limits, but the schema covers parameter details, making it adequately complete.

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

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

Schema description coverage is 100%, so the description adds no parameter meaning beyond what the schema already provides. Baseline 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 clearly states the tool lists policy versions with explicit ordering (newest first) and indicates the active version, making its purpose specific and distinct from sibling tools like put_policy or other getters.

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

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

Usage is implied by the name and description but not explicitly stated. No alternatives or when-not-to-use guidance is provided; however, the purpose is clear enough that an agent can infer when to call it.

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

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

No annotations are provided, so the description must disclose behavior. It adds that the tool is free and requires no auth, which is useful, but it does not explicitly state whether it is read-only, whether it executes trades, or how it interacts with external venues. It also doesn't describe return data or error handling, leaving gaps.

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

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

The description is a single sentence that immediately conveys the core function and then adds the free/no-auth qualifier. Every word earns its place; no wasted or redundant content.

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

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

With no output schema, the description should explain what the user receives (e.g., a list of quotes with prices, expiry, etc.), but it only says 'quote comparison.' It also doesn't explain how quotes relate to order placement, which is available in sibling tools. This leaves significant gaps for a simple 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 already provides full descriptions for all 4 parameters (100% coverage). The description adds context that the quoting is from CoW + ParaSwap on Base, but does not add parameter-specific syntax or format details beyond the schema. 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 clearly states the tool performs live venue quote comparison for token conversion, naming specific protocols (CoW + ParaSwap) and network (Base). This specific verb+resource distinguishes it from sibling tools that handle orders, intents, and account management.

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 for token conversion quoting but does not explicitly state when to use this over alternatives or when not to use it. No exclusions or alternative tool references are provided, making guidance only implicit.

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

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

With no annotations, the description carries behavioral disclosure itself. 'Deterministic... same period, same bytes' discloses reproducibility, 'append-only ledger' implies no mutation, and 'Auth required' states the permission prerequisite.

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

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

Two short sentences front-load the key behavior and add auth context. Every word contributes; no filler 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?

For a low-complexity getter with three fully documented parameters and no output schema, the description is nearly complete: purpose, determinism, source, and auth requirement are present. It does not cover error/edge-case behavior, but that is less critical 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 coverage is 100% and the input schema already describes wallet, period, and format with defaults. The description adds context about determinism but no additional parameter-level 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?

Description names a specific resource ('monthly statement') and a concrete behavior: it is derived deterministically from the append-only ledger. This clearly distinguishes get_statement from sibling get_balance/get_delegation/get_policy tools.

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

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

The description implies when to use it (when a reproducible monthly statement is needed) and notes that auth is required, but it does not explicitly state when not to use it or name alternatives among the many get_* siblings.

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It does add some value by stating the sort order ('newest first') and the auth requirement, but it omits other useful behavioral context such as pagination behavior, default result limits, or whether the operation is strictly read-only.

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

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

The description is two short sentences with no filler. It front-loads the core purpose and includes only one extra relevant behavioral note (auth requirement), making every word purposeful.

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 listing tool with only two optional parameters and no output schema, the description covers the essential aspects: what it lists, the ordering, and the auth requirement. It could be more complete by mentioning pagination or return format, but the tool's low complexity means this level is largely sufficient.

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 input schema already documents both parameters ('max results' and 'optional smart-account filter'). The description itself does not add parameter-level meaning beyond what the schema provides, 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 clearly states the action ('List delegations') and the specific resource ('delegations'), adding useful ordering information ('newest first'). This distinguishes it from singular sibling tools like get_delegation and other list_* tools for different resources.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as get_delegation, renew_delegation, or revoke_delegation. It only mentions that auth is required, which is a prerequisite rather than a usage condition.

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

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

With no annotations provided, the description carries the full burden and does disclose key access behavior: public, unauthenticated, and free. However, it doesn't mention read-only semantics, pagination, or potential large response sizes, leaving some behavioral ambiguity.

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

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

The description is two short sentences that efficiently convey the essential scope and access details. Every word contributes, with no fluff 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?

For a simple list endpoint with a single optional parameter and no output schema, the description adequately covers scope and access expectations. It doesn't describe the return structure, but the straightforward nature of the tool mitigates this gap.

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

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

The only parameter 'limit' is fully documented in the schema as 'max results', giving 100% coverage. The description adds no extra meaning beyond the schema, 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 identifies the resource as 'every feature request ever submitted' and highlights its public/unauthenticated access, which clearly distinguishes it from likely authenticated sibling tools. The verb is only implied by the tool name rather than explicitly stated, so it's clear but not maximally explicit.

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 useful context that no authentication is needed and the tool is free, implying when it can be used relative to other tools. However, it doesn't name alternative tools or explicitly state when not to use it, leaving the guidance implicit.

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

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

No annotations are present, so the description carries the full burden. It discloses authentication requirement and ordering behavior ('newest first'), but does not mention side effects (likely none, as it's a read-only list), error handling, or pagination details beyond the parameters. It adds some value but is minimal.

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 extremely concise: two short sentences, front-loaded with the primary action and ordering, followed by the auth requirement. No wasted words.

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

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

For a simple listing tool with 100% schema coverage and no output schema, the description is adequate. It communicates the action, ordering, and auth. It does not explain what an 'intent' is, but that is domain knowledge. The lack of output description is acceptable since no output schema exists and 'List' implies a list return. The description meets the needs for this simple 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 coverage is 100% (limit, offset, wallet all have descriptions). The tool description does not add any extra meaning beyond the schema, so the baseline score of 3 applies. No additional parameter context 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 clearly states a specific verb and resource ('List intents') and adds ordering ('newest first'), which distinguishes it from sibling tools like 'get_intent' (single) and 'create_intent' (creation). The plural 'List' implies multiple, differentiating it from singular getters.

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 the prerequisite 'Auth required' but does not explicitly state when to use this tool vs alternatives like 'get_intent' (for a single intent) or 'create_intent'. The context is implicit but not explicit enough to guide the agent on choosing between list and get operations.

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

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

With no annotations provided, the description carries the full burden, and it delivers meaningful behavioral context: 'never material' reassures the caller that secrets won't be exposed, and 'Auth required' sets expectations about authorization. It could go further by noting what happens on auth failure or whether results are paginated, but for a zero-parameter list, these two clausal disclosures address the most critical risks.

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 model of efficiency: a nine-word sentence followed by a two-word fragment delivers purpose, scope, return-type caveat, and auth requirement. Every phrase earns its place, and the key behavioral qualifier 'never material' is placed front-and-center after an em-dash for readability.

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 zero parameters, no output schema, and no annotations, the description covers the essential ground: what it lists, what it returns, and what's required (auth). The only minor shortfall is the absence of any mention of pagination, ordering, or empty-credential-set behavior, but for a tool this simple the description feels nearly complete.

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

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

There are zero parameters, and per the rubric, a tool with no parameters earns a baseline of 4 since there is no schema gap for the description to compensate for. The description adds no parameter-related content, but none is needed because the schema is trivially complete at 100% coverage.

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+resource construction: 'List stored venue credentials' with a scope qualifier 'metadata only, never material' that precisely defines what the tool returns. This clearly differentiates from siblings like store_pm_credential and revoke_pm_credential, which are visibly different operations on the same resource type.

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 implicit usage context by noting 'Auth required' and clarifying that only metadata is returned, which hints at a safe, non-secret read operation. However, it never explicitly states when to prefer this over alternatives like check_pm_order or list_pm_orders, nor does it mention exclusions. The guidance is adequate but relies on the sibling names to convey the surrounding workflow.

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

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

No annotations are provided, so the description carries the full burden. It discloses that authentication is required and implies a read-only fetch from the venue, but it does not mention rate limits, idempotency, or the exact nature of the data returned (e.g., pagination, sorting). It gives some insight but lacks depth.

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 extremely concise, using only two sentences and 18 words. It front-loads the primary action and includes a valuable usage hint. Every word earns its place; there is no fluff.

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 list endpoint with only two parameters and no output schema, the description provides adequate context by mentioning the state-recovery use case. However, it does not specify return format, ordering, or pagination, which could be expected for a list operation. It's adequate but not complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description reinforces that orders are tied to the credential, but it does not add any parameter-specific details beyond what the schema already provides. No new meaning is contributed.

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 indicates the tool retrieves resting orders for a credential, and adds the use-case 'recover state after a disconnect,' which differentiates it from simply 'listing' in a generic sense. It's not perfectly explicit (e.g., doesn't say 'fetches and returns'), but the meaning is clear given the tool name and sibling context.

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 'recover state after a disconnect' provides a specific scenario for when to use this tool, which is a clear usage guideline. However, it does not mention any alternatives or exclusions, nor does it compare with siblings like 'check_pm_order' or 'sync_pm_fills'.

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

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

With no annotations, the description adds behavioral context: 'Free, no auth' and clarifies the semantic tie to create_intent. However, it does not disclose potential rate limits, side effects, or output behavior, which would have enriched transparency.

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 extremely concise, using a single sentence (fragment) plus a short phrase. Every word adds value, and it is well-structured for quick scanning. The grammar is slightly informal but does not detract from clarity.

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 listing tool with one optional parameter and no output schema, the description covers purpose, usage, auth, and cost. It might benefit from mentioning response ordering or pagination, but these may be irrelevant given the tool's simplicity.

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 chain_id well, but the description adds semantic meaning by linking tokens to what create_intent will admit, providing contextual understanding beyond the raw parameter. It effectively communicates the 'per chain' filtering.

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 (tokens) and scope (per chain, what create_intent will admit). Although it lacks an imperative verb, the tool name and context make the listing action clear. It distinguishes itself from siblings like list_intents by tying to intent admission.

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

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

It implies when to use (when checking acceptable tokens for an intent) and notes no auth is needed, but it does not explicitly contrast with alternate tools or state when not to use. The 'per chain' hints at the chain_id parameter, but exclusions are absent.

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

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

Since no annotations are provided, the description fully carries the burden. It transparently discloses that the action is irreversible, requires authentication, and has specific effects (revokes credentials, scrubs personal data). The confirmation requirement is also highlighted, which is critical for such a destructive operation.

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 concise and well-structured, using three sentences to convey purpose, effects, irreversibility, and the confirmation requirement. There is no superfluous information, making it easy for an agent to parse.

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 account-offboarding tool, the description covers essential context: what it does, consequences, irreversibility, and the confirmation safeguard. It does not need to explain return values since no output schema is provided. The description is sufficiently complete for an agent to understand the operation and its risks.

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 describes both parameters, but the description adds crucial nuance: 'confirm_wallet_address must be the account's own wallet address, typed exactly.' This clarifies the validation requirement beyond the schema. The optional 'reason' parameter is not elaborated, but that is acceptable given its optional nature.

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's purpose: 'Close this account for good' and details the consequences (revokes credentials, scrubs data, retires account). It is distinct from other sibling tools, which focus on different actions like canceling orders or managing credentials.

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 implicitly communicates when to use (permanent account closure) and emphasizes the destructive nature ('Irreversible'). However, it does not explicitly mention alternatives or when not to use, but the context is clear enough for an agent to select it appropriately.

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?

Discloses key actions (suspend, revoke, return calldata) and the auth requirement. Lacks explicit mention of irreversibility or side effects, but the description is reasonably transparent given no 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?

Concise single sentence with clear, structured listing of effects. No redundant 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?

Completely describes the tool's purpose and required auth. The return value 'unwind calldata' is mentioned but not elaborated; this is acceptable without an output schema, though a bit more detail could improve completeness.

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

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

The optional 'reason' parameter is fully described in the schema (100% coverage), so baseline is 3. The description does not add extra 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?

Clearly describes the tool's action: suspends the account, revokes all credentials, and returns unwind calldata. Distinct from siblings as an emergency stop.

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?

Labels it as an 'Emergency stop, one call' which implies usage in critical situations, and notes 'Auth required'. However, it does not explicitly state when not to use it or mention alternatives.

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

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

With no annotations, the description carries the full burden. It discloses the monotonic cursor behavior and auth requirement, but does not mention whether it is read-only, return format, pagination limits, or error behavior. These gaps are significant for a polling tool.

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

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

Two sentences, front-loaded with the key action and resource. Every word earns its place; the event categories are concise and informative. No verbosity.

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

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

With no output schema, the description should explain the return shape or behavior. It does not describe what the response looks like (e.g., list of events) or how pagination works. Given the moderate complexity and four optional params, the description is incomplete for a tool that needs to be understood without examples.

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% with each parameter having a description, so baseline is 3. The description adds context about the cursor being monotonic and event typing, but does not add syntax details beyond the schema. It is adequate but not compensatory.

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

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

The description clearly states the action (poll) and resource (typed treasury events) with concrete event categories (intent lifecycle, budget thresholds, reconciliation, security alerts). It distinguishes from sibling list_* tools by focusing on a monotonic cursor event stream, though it doesn't explicitly name an alternative.

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

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

It implies usage for retrieving treasury events with a cursor and notes that auth is required. However, it does not provide explicit when-to-use versus list_* tools, nor any conditions for when not to use it. The context is sufficient for basic understanding but lacks exclusionary 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?

With no annotations provided, the description carries the full burden. It explicitly states that the tool returns the ONE EIP-712 digest and that the server cannot sign, setting accurate expectations. It also mentions 'Auth required,' but does not detail the exact auth mechanism or any side effects (e.g., does it persist anything?). Since it is a preparation step, it likely doesn't mutate state, but that is not stated. Still, it provides useful behavioral context beyond the schema.

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

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

The description is a single, dense sentence that packs purpose, key constraints, return value, next step, and a caveat (cannot sign) without any fluff. It is front-loaded with the action and resource, and the critical limitation (no signing) is highlighted. Every phrase earns its place; no redundant words.

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

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

Given the tool's complexity (nested objects, 6 params), the description is adequate. It explains the high-level purpose, the return digest, the next step (confirm_delegation), and auth requirement. It does not detail the output schema (none exists), but that's not needed. It could mention that the digest must be signed with the account owner's key and that confirm_delegation will accept the signature, but that is implied. Complete enough for safe usage.

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 meaning by highlighting the key constraints: 'exact call allowlist' and 'optional rate limit', and clarifies the flow. It does not repeat parameter-by-parameter details, but the nested objects are well described in the schema. The description helps the agent understand which parameters are essential for scoping (calls, valid_until) and optional (rate_limit, valid_after). This adds value 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 clearly states the tool's purpose: to prepare a scoped session-key grant for a Kernel smart account with exact call allowlist, expiry, and optional rate limit. It uses a specific verb ('Prepare') and resource ('delegation'), and differentiates it from siblings like confirm_delegation, renew_delegation, revoke_delegation, and get_delegation by emphasizing the preparation step and the off-chain signing requirement.

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 clearly explains when to use this tool: to prepare a delegation before signing, followed by confirm_delegation with the signature. It also states that this server cannot sign, guiding the agent to expect external signing. However, it does not explicitly mention when NOT to use it or alternatives like renew_delegation for renewals or revoke_delegation for revoking, but the context is clear enough for selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the server cannot sign, returns an unsigned EIP-712 payload and prepare_id, performs a policy check, and requires auth. It does not mention side effects like whether a prepared order record persists or expires, but the core behavioral trait (preparation only) is explicit.

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

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

A single dense sentence delivers purpose, workflow, limitation, and auth requirement without redundancy. It is front-loaded with the main action and every clause adds value.

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

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

This is a complex tool with 10 parameters and no output schema, so describing return values is essential. The description adequately explains the two-part return (payload + prepare_id) and the follow-up submission. It lacks details on policy-check failure modes, expiration, or the state parameter's role, but the main workflow is clear enough for an agent to proceed.

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

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

Schema description coverage is 80%, so the baseline is 3. The description adds context about the output being an EIP-712 payload, which connects the parameters to the signing flow, but does not add per-parameter semantics 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?

Uses a specific verb 'Prepare' with a precise resource 'client-signed Polymarket order' and explicitly describes the outputs (EIP-712 payload, prepare_id) and the follow-up tool (submit_pm_order). This clearly differentiates it from sibling submission 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?

Clearly states the workflow: prepare here, then submit both via submit_pm_order. It implicitly distinguishes from server-signed creation by emphasizing client-signing and the server's inability to sign, but does not explicitly name create_pm_order as an alternative or provide when-not-to-use scenarios.

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

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

With no annotations, the description carries full burden. It transparently discloses that it's a write operation, requires auth, yields a new immutable version, applies platform defaults to omitted fields, and includes defaulted fields in the response. This goes beyond minimal and addresses potential side effects.

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 reasonably concise for the amount of information, though the long sentence about defaults could be broken down. It front-loads purpose and key constraints (immutability, auth, schema), with no redundant words.

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

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

Given the tool complexity (nested object policy, mutation, no annotations, no output schema), the description covers the essential operational details: auth, schema reference, required fields, default application, and response's `defaulted` list. It does not describe the full response shape, but the schema reference and sibling context help fill the gap.

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

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

Schema description coverage is 100% and the schema even gives a concrete example. The description adds extra semantic value by referencing the external schema, naming required fields, and explaining default behavior, which is not in the schema itself.

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 verb ('Create or update') and resource ('the wallet's treasury policy'), and distinguishes from siblings by noting immutable versioning (PUT creates the next version), which differentiates it from tools like get_policy that only read.

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

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

The description says when auth is required and what body must match, providing useful constraints, but it does not explicitly state when to use this tool vs alternatives (e.g., when to read with get_policy vs create/update here) or when not to use it. Some guidance is implied but not fully 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?

No annotations are provided, so the description carries full responsibility. It states 'Auth required' but does not disclose whether the action is reversible, what happens to the rule, or what 'unused authorizations' implies. The destructive nature is only implicit from 'remove'.

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 sentence that conveys the purpose and the auth requirement with no unnecessary words. It is front-loaded and perfectly concise.

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

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

For a simple tool with no parameters and no output schema, the description covers the core action and the auth note. However, it could be more complete by stating the context of use (e.g., to disable auto-topup) or any side effects. It is adequate but leaves some room for additional context.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-related information because none is needed. It does not need to compensate for any schema coverage gaps since there are no parameters.

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

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

The description clearly states the action (remove) and the resource (auto-topup rule), and mentions 'unused authorizations' which adds specificity. It distinguishes itself from sibling tools like get_auto_topup and set_auto_topup by indicating a removal operation.

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 mentions 'Auth required' but does not provide explicit guidance on when to use this tool versus alternatives, such as when to disable an auto-topup rule or with which other tools it might interact. The context is implied but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden. It discloses that auth is required and that the tool returns a new digest for signing, and it clarifies the renewal semantics. However, it does not state side effects, what happens to existing pending confirmations, or behavior on invalid/inactive delegation IDs.

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 concise sentences with no wasted words. Key facts are front-loaded: the action, scope, expiry, authority gap, and follow-up signing flow.

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

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

For a simple two-parameter tool with no output schema, the description covers purpose, required auth, and next-step flow. It could mention error/precondition details, but it is reasonably complete for an agent to select and invoke 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 no additional parameter meaning beyond the schema; it mentions the new expiry concept implicitly but the schema already documents 'valid_until' and its default behavior.

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's action: 'Renew an active delegation' with specific semantics ('same scope, fresh expiry, no authority gap'). It distinguishes itself from siblings like prepare_delegation and revoke_delegation by focusing on renewal of an existing active delegation.

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 practical usage context: it applies to an 'active delegation', requires auth, and instructs the agent to follow the same confirm flow as prepare_delegation. It doesn't explicitly state when NOT to use it or name direct alternatives, but the context is clear enough.

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

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

No annotations are provided, so the description carries the full burden. It does reveal that auth is required and that the operation resolves an owner to candidates, implying a lookup. However, it does not disclose output format, failure behavior, rate limits, or why 'candidates' exist, leaving meaningful gaps.

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

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

Two short sentences convey the core purpose and an important requirement (auth). There is no padding, redundant phrasing, 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 single-parameter lookup with no output schema and no annotations, the description is minimal but functional. It states the operation and auth need, yet leaves uncertainty about what the returned candidates look like and how the response should be interpreted.

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 already documents the owner parameter. The description restates the same concept ('owner EOA') without adding detail beyond the schema, meeting the baseline but not exceeding it.

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 ('Resolve') and a specific resource ('owner EOA to its Polymarket funder Safe candidates'), clearly distinguishing it from the many read/list/check sibling tools. It precisely states what the tool accomplishes.

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 no guidance on when to use this tool versus alternatives such as get_pm_onboarding, get_pm_signer_rotation, or list_pm_credentials. It only mentions auth as a requirement, not the conditions or workflow context.

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

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

The description discloses a key behavioral aspect: the reply includes calldata for on-chain hard finality, implying the tool itself does not finalize on-chain. It also mentions 'Auth required.' However, it does not describe side effects on the delegation record or any state changes beyond the calldata, so transparency is partial.

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

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

The description is concise and well-structured, consisting of two short sentences with no redundant or vague wording. It efficiently conveys the essential purpose and a key behavioral note.

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, but the description lacks context about its relationship to sibling delegation tools, potential side effects, or error conditions. It does not explain how it differs from 'cancel' or 'confirm' beyond the name, and the output schema is absent but the calldata mention is minimal. Overall, incomplete for full contextual understanding.

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 parameter 'id' is only described as 'delegation id (uuid)', which merely repeats the schema's type and format. No additional meaning, constraints, or context is provided, so the description adds no value 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 verb 'Revoke' clearly indicates the action, and the resource 'delegation' is specific. It distinguishes from sibling tools like 'confirm_delegation' or 'renew_delegation' by the action. The added detail about calldata for hard finality enhances clarity.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not specify prerequisites, context, or when not to use it, leaving the agent to infer usage from the action name alone.

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

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

No annotations exist, but the description discloses behavioral specifics: sealed ciphertext is destroyed, authorization is required. However, permissions, error handling and reversibility/irreversibility are not discussed.

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?

Single concise sentence with no redundant exposition; defines the core action and the side effect.

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 credential revocation tool, the description is clear on outcomes and side effects (destroys sealed cipher). But context for nonexistent IDs or invalid permissions is absent; no return schema exists, though the action is straightforward.

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 100% covered and adds minor context that id is a credential id (UUID). The description does not explain parameter value behaviors, but there is only one parameter.

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

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

Description uses specific verb 'Revoke' plus resource 'venue credential' and explicitly states the sealed ciphertext is destroyed. This is unambiguous and distinct from sibling tools that revoke delegations.

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?

Clear command to revoke a credential, but does not explicitly state when to use this vs. alternatives like revoking a delegation, nor any prerequisites such as the credential needing to exist.

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

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

No annotations are provided, so the description carries the burden for behavioral disclosure. It adds useful context by noting the tool is free and requires no auth, but it omits crucial behaviors like output format, what constitutes a match, or any rate limitations. This is minimal but not completely bare.

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, tightly worded sentence that immediately communicates the core function and key differentiators (free, no auth). There is no filler or redundancy; every word contributes value.

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 in terms of parameters, but it lacks an output schema and detailed behavior. The description does not clarify what the tool returns (e.g., boolean match, list of sanctions, or whether a clean result is also indicated). Given the sensitivity of OFAC screening, users likely need more context about the response semantics, so the description falls short of completeness.

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

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

The input schema fully describes the single parameter ('EVM address to screen'), giving 100% coverage. The description does not add extra meaning beyond that, but since schema coverage is high, a baseline 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 states a specific verb ('screening') and resource ('address'), clearly identifying the tool's function: OFAC SDN counterparty screening. It is distinct from any sibling tool, making its purpose unambiguous.

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

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

The description implies usage by mentioning it is free and requires no auth, which suggests when it might be preferred (e.g., no authentication overhead). However, it does not explicitly state when to use this tool versus alternatives, nor does it describe exclusions or prerequisites beyond the address parameter.

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

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

With no annotations, the description carries the burden. It discloses a critical limitation ('this server cannot sign') and auth requirements, but does not explain side effects like replacing existing auto-topup config, impact on balances, or behavior when authorizations are spent or expire. The provided constraints are useful but incomplete.

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

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

A single, dense sentence packs the core purpose, trigger condition, key restriction (no signing), and auth requirement. Every clause earns its place, and it is front-loaded with the action. 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?

The description covers the trigger and input but omits post-configuration behavior (e.g., confirmation, how to check existing config via get_auto_topup, or whether settings are replaced). Since there is no output schema and no annotations, a little more context about effects and verification would improve completeness, though it is adequate for a straightforward config 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 schema has 100% coverage, so a baseline of 3 applies. The description adds meaning by explaining that 'threshold_usd' triggers the top-up and that 'authorizations' are pre-signed payloads used for settlement. It does not elaborate on 'max_per_month' but that is adequately described in the schema. Overall, it enhances understanding beyond the raw 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 opens with 'Configure auto-topup', specifying the exact action and resource. It then explains the trigger condition (balance below threshold) and the mechanism (pre-signed EIP-3009 authorizations), which clearly distinguishes it from siblings like get_auto_topup, remove_auto_topup, and topup_balance.

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 conveys when the tool is used (when configuring automatic refills) and includes a key prerequisite ('Auth required' and the need for pre-signed authorizations). It does not explicitly list alternatives, but the context of configuring vs. manual top-up (topup_balance) is implied.

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

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

With no annotations provided, the description carries the full burden and does well: it reveals single-use nature, external signing requirement, server-side signing limitation, and no-auth/no-cost status. These are important behavioral traits beyond what a raw schema would 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 tightly packed sentences front-load the purpose and next action, with every phrase earning its place. No redundant or filler content.

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

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

For a low-complexity, two-parameter tool with no annotations and no output schema, this description is complete: it explains what is returned, the external signing constraint, the required follow-up call, and the auth/cost context. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-specific meaning beyond the schema's 'wallet address to authenticate' and '8453'; it does not explain chain_id semantics further, but it is not required to compensate given full coverage.

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

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

The description states the exact action ('Start wallet sign-in') and return value ('a single-use SIWE message'), clearly distinguishing it from the sibling complete_siwe_login by framing it as the first step of a two-step flow.

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 workflow instructions: sign externally because the server cannot sign, then call complete_siwe_login. It also clarifies the auth/cost context with 'Free, no auth,' which removes ambiguity about prerequisites.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It goes beyond a simple 'store' by disclosing that credentials are verified live against the venue, sealed at rest, and that the material is never returned. It also states that authentication is required. This is comprehensive for a credential storage 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 concise (three sentences) and front-loaded with the core purpose. Every sentence adds value: the first defines the action and key safety properties, the second details the accepted credential shapes, and the third states the authentication requirement. No fluff or redundant 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?

Given the tool's complexity (9 parameters, two mutually exclusive shapes, no output schema), the description covers the essential aspects: what it stores, supported shapes, safety guarantees (never returns material), and auth. It does not explicitly state what the tool returns (e.g., a confirmation or label), but 'material never returned' partially mitigates that. The optional parameters (label, signature_type) are documented in the schema, so the description is complete enough for an agent to invoke the tool 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?

Although the schema has 100% description coverage for individual parameters, the description adds crucial grouping by presenting two distinct shapes (signer_private_key + maker, or api_key + secret + passphrase + maker + signer). This semantic relationship is not evident from the schema alone and helps the agent choose the correct parameter set. It does not explain optional parameters like label or signature_type, but those are self-explanatory in 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 clearly states the action ('Store a prediction-market venue credential'), the exact resource (credential for prediction-market venues), and distinguishes it from sibling tools like list_pm_credentials and revoke_pm_credential. It also specifies supported venues (Polymarket) and credential shapes, leaving no ambiguity about what the 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?

It provides clear context for when to use the tool (storing a credential) and specifies the accepted input shapes (either signer_private_key + maker or api_key + secret + passphrase + maker + signer). It does not explicitly contrast with alternatives, but the purpose is clear enough that an agent would infer the correct usage. 'Auth required' adds a prerequisite.

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

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

With no annotations, the description carries full responsibility and does so excellently. It discloses the fee, auth requirement, the server's inability to sign, and the exact structure of the required x_payment payload. This is exemplary transparency for a mutation 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 dense but every sentence earns its place: purpose, fee, auth, and the two-step payment flow are all essential. It's somewhat long but well-structured with a colon and em dash separating the flow steps. Minor improvements could make it easier to parse.

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

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

The description fully covers the complex payment interaction: the failure mode (402), the required signing steps, and the exact payload format. No output schema exists, but the description explains what the user will receive (402 details) and what to do next. There are no gaps in the behavioral contract.

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 describes title, body, and x_payment with constraints. The description adds crucial semantics for x_payment by explaining it's the base64 value from the 402 response, which goes beyond the schema's simple description. Given full schema coverage, this extra detail earns above baseline.

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 'Submit a feature request', a specific verb+resource pair. The addition of the $1 anti-spam fee and the payment flow clearly distinguishes this from sibling tools like list_feedback, making the tool's unique 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?

Provides explicit procedural guidance: first call without x_payment to receive a 402 with EIP-3009 requirements, then sign externally and retry with x_payment. This step-by-step instruction fully explains how to use the tool and what the two-phase flow entails.

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

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

With no annotations provided, the description must carry behavioral disclosure. It mentions 'Auth required,' which is useful, but it doesn't describe what happens on submission (e.g., on-chain effect), failure modes, or idempotency. This is minimally transparent for a mutating action.

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

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

The description is a single, front-loaded sentence with no filler. It states the action and key dependency in a concise manner.

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?

While the tool is simple (2 params, no output schema), the description gives only the core purpose and auth requirement. It doesn't address potential edge cases, expected return values, or post-conditions, which could matter for an AI agent deciding whether to call it. It's adequate but minimal.

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% for both parameters with clear descriptions. The tool description adds no new parameter information beyond restating the source of prepare_id. Baseline of 3 is appropriate since the schema already documents the parameters.

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

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

The description clearly states the action ('Submit') and the resource ('a prepared Polymarket order with the maker's EIP-712 signature'), and it explicitly references the originating tool (prepare_pm_order), distinguishing it from siblings like create_pm_order or prepare_pm_order.

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

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

It implies the tool should be used after prepare_pm_order by naming that tool in the description. It also notes 'Auth required,' which provides usage context. However, it doesn't explicitly mention when to avoid using it or name alternative tools, so it misses full exclusion criteria.

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

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

With no annotations, the description carries full burden. It discloses idempotency and auth requirements, which are key behavioral traits. It could mention side effects or failure modes but is adequate.

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

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

Two concise sentences with no redundancy, covering the core action and two key behavioral notes.

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

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

The description covers the primary operation, idempotency, and auth, which is sufficient for most use cases. It does not elaborate on return values or edge cases, but that is not required given the simple 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?

The schema already provides detailed descriptions for both parameters (wallet and credential_id). The description adds context about the flow but does not significantly enhance parameter understanding beyond 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 clearly states the action ('Pull the venue's fills') and the target ('into the wallet's ledger'), distinguishing it from sibling tools like cancel or check operations.

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

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

It implies usage for syncing fill data from a venue, but does not explicitly compare to other tools or state when to prefer it. The clarity of purpose makes it obvious enough.

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

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

With no annotations provided, the description carries the full burden and does so excellently. It discloses auth requirements, the two-phase 402 challenge flow, the server's inability to sign, and the exact expected x_payment payload structure. This goes well beyond a basic 'top up' statement.

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, each earning its place: purpose, auth note, and the two-step payment flow. No filler or repetition; front-loaded with the primary action.

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

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

The description covers the complex two-step payment protocol thoroughly, including the 402 response, external signing requirement, and second-call payload. It does not describe the success response or post-payment behavior, but given the complexity and lack of output schema, it is nearly 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 the baseline is 3. The description adds meaningful semantics for x_payment by explaining its origin (from a 402 reply) and its internal structure, which is not fully captured in the schema. amount_usd is adequately described by both schema and description.

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

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

The description opens with a specific verb and resource: 'Top up the prepaid balance with USDC.' This clearly distinguishes the tool from siblings like get_balance or set_auto_topup, and the payment-flow detail reinforces its unique purpose.

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, step-by-step usage instructions: call without x_payment, receive a 402 with EIP-3009 requirements, sign externally, then call again with x_payment. It does not explicitly discuss alternatives or when-not-to-use, but the context is strong enough to guide 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?

No annotations are provided, so the description must carry behavioral burden. It discloses that auth is required and that the operation is platform-relayed (no gas to user), but doesn't mention side effects, failure modes, or what happens to the wrapped funds. Some behavioral context is given, but not comprehensive.

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, starts with the verb and resource, and includes essential tips (full balance, auth). No fluff, every word earns its place.

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

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

For a simple wrap operation, the description covers the main aspects: what it does, how to use the optional amount, and the auth requirement. It lacks mention of return value or error handling, but with no output schema, it could be slightly more complete. Still, it is adequate for the tool's complexity.

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

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

Schema coverage is 100% (both parameters have descriptions), so baseline is 3. The description adds value beyond schema by explaining that omitting amount_base_units wraps the full balance, which clarifies the optional parameter's semantics. This extra guidance warrants a 4.

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

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

The description clearly states the action (wrap) and the specific resource (funder Safe's USDC.e into Polymarket's pUSD). It also mentions platform-relaying and no gas, distinguishing it from sibling tools like topup_balance or get_balance. The verb and resource are unique 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?

Provides a clear usage hint: 'Omit amount_base_units to wrap the full balance' and notes 'Auth required.' It doesn't explicitly say when not to use or name alternatives, but the context (platform-relayed, no gas) implies when it's preferable. Lacks direct comparison to siblings, but enough guidance for correct invocation.

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