AI Agent Tokenized Stock OS

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

With no annotations, the description carries full burden and discloses a key behavioral trait: the API key is shown only once. This is critical for agent decision-making. However, it does not mention failure handling, authentication requirements, or rate limits.

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

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

The description is a single, well-structured sentence that packs essential information with no wasted words. It is front-loaded 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 has 3 parameters and no output schema, the description is too minimal. It does not explain the return value, the verification process, or how the API key is delivered. An agent would need additional context to use it effectively.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (tier, owner, txHash). This leaves the agent without guidance on how to populate them, forcing reliance on schema names alone.

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

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

The description clearly states the action 'verify and issue API key' and specifies the precondition 'after ETH payment to treasury is confirmed'. It effectively distinguishes itself from sibling access tools like checkout and pricing.

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 after payment confirmation but does not explicitly state when to use or avoid this tool versus alternatives. No sibling comparisons or exclusion criteria are provided.

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 tool builds an on-chain payment plan, implying a transaction, but it doesn't mention side effects, permissions, or error conditions. The description is moderately transparent 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: two sentences with no fluff. The first sentence states the purpose, and the second provides the next step. Every word serves a useful function.

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 lack of annotations, output schema, and parameter descriptions, the tool definition is incomplete. The description covers high-level purpose and a post-condition but fails to explain inputs, output, or behavior, leaving significant ambiguity.

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

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

The input schema has 2 parameters (tier and owner) with 0% schema description coverage. The description does not mention or explain any parameters, leaving the agent without guidance on how to populate them. This is a critical gap.

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

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

The description clearly states the tool's function: it builds an on-chain ETH payment plan for Pro/Team tiers. The verb 'build' and resource 'on-chain ETH payment plan' are specific, and the scope (Pro/Team) differentiates it from sibling tools like pricing, status, or activation.

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 a clear sequential guideline: after the user pays, call stocktoken_access_activate. This helps the agent understand the workflow. However, it does not explicitly state when not to use this tool or offer alternatives, so some guidance is missing.

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 implies a read-only list operation by stating it lists pricing, but does not explicitly declare it as non-destructive, nor does it disclose authentication needs, rate limits, or side effects. Adequate but not thorough.

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

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

One concise sentence covering key points (free/pro/team pricing, payment method, agent payment). No fluff, but could be improved by adding structure or bullet points for 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?

Given no output schema and no parameters, the description is reasonably complete. It explains the what and a notable detail (ETH on-chain, no Stripe). However, it lacks details on output format or any constraints, which are not critical but would enhance 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?

No parameters exist, and schema coverage is 100%, so the description adds no parameter info. Baseline is 4 per rubric; description appropriately omits param details.

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 Free/Pro/Team pricing and how agents pay for write tools. It uses specific verb 'List' and specifies the resource 'pricing', distinguishing it from siblings like stocktoken_subscription_tiers by mentioning payment details (ETH on-chain, no Stripe).

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

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

No guidance on when to use this tool vs alternatives such as stocktoken_subscription_tiers or stocktoken_fees. The description does not mention prerequisites, context, or when not to use it, leaving the agent to infer usage without explicit direction.

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 provided, so the description must fully convey behavior. It implies a read-only check but does not explicitly state idempotency, side effects, authentication needs, or return format.

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

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

Single sentence, no filler, efficient communication of purpose and parameter behavior.

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 one simple parameter and no output schema, the description covers the two modes of operation adequately but omits behavioral details like safety profile (read-only) and return structure.

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

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

Schema coverage is 0%, but the description adds meaning: the 'owner' parameter is optional and defaults to the current API key context. This clarifies the parameter's role, though the format (e.g., address) is not specified.

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 clearly states the purpose: 'Check paid access for current API key context or a wallet owner.' It uses a specific verb ('Check') and resource ('paid access'), and distinguishes itself from sibling tools like stocktoken_access_activate and stocktoken_access_pricing by focusing on status checking.

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

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

No guidance on when to use this tool versus alternatives (e.g., stocktoken_subscription_status). No explicit when-not or context for 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?

With no annotations, the description carries the full burden and handles the most important trait: this is a non-mutating preview, not a swap or deposit. It does not disclose auth requirements, data freshness, or return shape, but the mutation boundary is clearly drawn.

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

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

Two short sentences, zero waste, with the scoping constraint and the exclusion/alternative routing front-loaded. Every clause earns its place.

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

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

For a zero-parameter tool with no output schema, the description is nearly complete on safety and routing, but it never explains how the basket is identified (e.g., session state) or what a preview returns. The agent is left to infer how to actually invoke it meaningfully.

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

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

Zero parameters, so the baseline is 4. There is no parameter syntax to explain, and the schema is empty by design; the description appropriately does not invent parameter guidance.

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

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

States a specific verb and resource ('Preview basket prices only') and immediately differentiates itself from swap and vault-deposit operations. It is clear and distinct from siblings like stocktoken_quote, though the term 'basket' itself is never defined.

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

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

Explicitly states what this tool is NOT ('does not swap', 'not a vault deposit') and routes the agent to the correct alternative for the single-token case ('use stocktoken_quote then stocktoken_execute_plan'). When-not-to-use and alternatives are both covered.

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

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

Annotations only declare it as a non-read-only, non-idempotent, open-world mutation, and the description adds substantial context on top: it does NOT sign or broadcast, the user signs, steps consist of ~10 bps ETH fee, approve, and swap, v4 adds a Permit2 approval, and a v4 plan expires after 30 minutes. These are exactly the behavioral traits an agent cannot infer from the annotations.

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

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

Five short sentences, front-loaded with the core action and chain, then venue logic, then steps, then the critical non-signing constraint, then expiry. Every sentence carries distinct information and none restates the tool name or annotations.

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 9-parameter mutation tool with no output schema, the description covers composition, prerequisites, and lifetime well enough to call it correctly. It could have gone further by describing the shape of the returned plan (what fields an agent should surface before the user signs), which is the remaining gap.

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

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

Schema description coverage is 100%, so every parameter (owner, tokenIn/Out, slippageBps default, notionalUsd policy check, approveMax) is already documented at the field level. The description adds no parameter-level syntax or format guidance beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Build an unsigned swap plan on chain 4663') plus the mechanism for venue selection (higher amountOut among v4, v3, 0x, Uniswap API). An agent immediately knows this produces a plan rather than executing a swap. It does not explicitly contrast itself with siblings like stocktoken_quote or stocktoken_simulate, so it stops short of a 5.

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

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

Usage is implied rather than stated: the description explains what the plan contains but never says when to prefer this over stocktoken_quote, stocktoken_simulate, or stocktoken_intent_typed_data. It does surface one real precondition ('Pro required') and one operational constraint (v4 plan expires in 30 minutes), which lifts it above a bare 2.

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, and it largely discharges it by disclosing the routing decision rule itself. It implies a safe, non-mutating explain operation and reveals the chain-id scoping constraint, though it never states the output form or that unknown intents may be unrouted.

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

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

Three short sentences, front-loaded with the directive 'Start here,' with zero filler. Every clause carries a routing decision or a destination list.

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 dispatcher tool with no annotations and no output schema, the description covers the essential decision surface: broker vs on-chain, the chain id, and the sibling tools to continue with. Only the return shape and handling of ambiguous intents are unaddressed.

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

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

There is one parameter (userIntent) with 0% schema description coverage, and the description says nothing about its expected format, granularity, or examples. The routing categories hint at what intents look like, but the parameter itself is left undocumented in both schema and prose.

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 role (routing guide) and draws a hard line between brokerage equities (Robinhood Trading MCP) and on-chain Stock Tokens on chain 4663 (this server). It names the concrete destination siblings (stocktoken_list, stocktoken_price, stocktoken_quote, stocktoken_execute_plan), so an agent can act without opening other schemas.

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

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

'Start here' is an explicit when-to-use instruction, and the description names the alternative destination (Robinhood Trading MCP) plus the condition that selects each path (brokerage equities vs chain-4663 Stock Tokens). This is exactly the routing guidance an entry-point tool needs.

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 correctly indicates read-only behavior by stating 'summarize' and 'status', which implies no destructive actions. However, it lacks details on authentication or rate limits, but for a simple summarization tool this 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?

The description is a single, efficient sentence that starts with the verb 'Summarize' and contains no extraneous words. It is front-loaded and to the point.

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

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

For a no-parameter, no-output-schema tool, the description sufficiently explains the purpose. It could mention return format or data freshness, but the context is clear 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?

There are no parameters (schema coverage 100%), so baseline is 4. The description adds meaning by specifying what the summary includes (fee events, treasury/ETH fees), going beyond the empty 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 summarizes AATOS execution fee events and on-chain monetization status, using specific verbs and resource context. It distinguishes itself from sibling tools that cover pricing, metrics, or other aspects.

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 is given. It implies a read-only fee summary role but does not mention alternatives or scenarios where other tools are more 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?

With no annotations, the description carries the full disclosure burden. It usefully discloses scope limits (v3-only, not a fill check, no v4 visibility), but says nothing about read-only nature, permissions, rate limits, or what is actually returned beyond 'pool addresses'.

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

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

Three tight sentences with the scope constraint front-loaded and alternatives last. 'Fill check' is slightly jargon-heavy but the overall structure is efficient with no filler.

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

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

No output schema and no annotations exist, so the description must cover behavior and return semantics, yet it leaves both parameters and output format undocumented. Scope and routing are handled well, but the definition is incomplete for a 2-param lookup tool.

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

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

Schema coverage is 0% and the description never mentions tokenA or tokenB. It only implies a token pair is needed; it does not clarify whether inputs are addresses or symbols, whether order matters, or how pairs map to pools. The description fails to compensate for the uncovered 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 states a specific resource and scope ('Uniswap v3 pool addresses only') and explicitly distinguishes itself from v4 pools and from swap flow tools. An agent can tell it apart from stocktoken_quote and stocktoken_execute_plan, though the exact verb ('find') and return shape are only implied.

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 both a negative boundary ('not a fill check', 'does not see v4') and an explicit alternative path for the swap use case ('use stocktoken_quote then stocktoken_execute_plan'). It stops short of stating the positive trigger condition for calling this tool directly.

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 fully disclose behavioral traits. It indicates the tool is a read-only lookup ('Get metadata') but does not specify what fields are returned, authorization requirements, rate limits, or any potential side effects. While the intent is clear, the lack of return structure details leaves some 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 concise sentences that front-load the action and purpose. Every word is necessary, with no redundancy or filler. It efficiently communicates the tool's function and typical use case.

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

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

For a simple lookup tool with one parameter and no output schema, the description covers the primary use case and identifier types. Adding a note about the metadata returned (e.g., 'name, symbol, decimals') would make it fully complete, but the current level is sufficient 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?

The input schema has 100% description coverage for the single parameter 'symbolOrAddress', explaining it accepts tickers or contract addresses. The description adds context about the blockchain ('Robinhood Chain 4663') and the purpose, which is helpful but does not significantly extend schema semantics. 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 uses a specific verb ('Get metadata'), identifies the resource ('canonical Stock Token or core asset'), and specifies identifiers ('symbol or contract address'). It also states the use case ('verify a token is official before trading'), clearly distinguishing it from sibling tools like 'stocktoken_list' which would return multiple tokens.

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

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

The description explicitly states when to use this tool: 'Use to verify a token is official before trading.' It does not explicitly state when not to use it, but the context of sibling tools (e.g., 'stocktoken_list' for listing all tokens) provides implicit guidance. A clearer exclusion for alternative tools would improve the 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?

No annotations are present, so the description carries full burden. It discloses that user signs and onchain verifies later, but does not detail any side effects, permissions, or data flow beyond building typed data. Adequate but 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?

Two sentences clearly convey the tool's purpose and high-level workflow. No unnecessary words, front-loaded with key 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 complexity (8 parameters, no output schema), the description is too brief. It lacks details on parameter roles, constraints like nonce or deadline, and return value expectations. The agent would need to infer too much from parameter names alone.

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?

With only 13% schema description coverage (only tokenIn has a description), the description adds no parameter-level meaning. For 8 parameters, including 5 required ones, this is insufficient to help an agent understand how to populate them correctly.

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

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

The description clearly states it builds EIP-712 typed data for agent trade intents, specifying the offchain authorization nature and the user signing flow. This is unique among siblings, as no other tool explicitly handles typed data construction.

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

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

The description implies the tool is for offchain authorization but does not explicitly state when to use it versus alternatives like stocktoken_permit2_prepare. No exclusions or contextual guidance is provided.

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

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

With no annotations, the description carries the full burden and does add real behavioral context: it defines what a row contains, explains the eitherExecutable flag, and explicitly scopes the coverage caveat that hooked v4 pools are not scanned. That negative-space disclosure is valuable. It stops short of describing freshness, refresh cadence, or result format.

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

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

Four short sentences, front-loaded with what the tool is before the interpretive caveats. Minor telegraphic/inconsistent phrasing ('each row reports', lowercase mid-sentence) but no filler that could be cut without losing a constraint.

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

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

For a zero-parameter read tool with no output schema, the description conveys what the rows mean and how to interpret the boolean against stocktoken_quote, which is the main thing an agent needs. Exact column layout and data freshness remain unstated but are not blocking.

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

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

The tool takes zero parameters, so the baseline is 4; there is no parameter syntax to explain and the description spends its words on row semantics instead, which is the right allocation.

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

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

States a specific resource and scope: a liquidity matrix for major USDG pairs on chain 4663, with rows covering hookless v4 and on-chain v3. This is concrete enough to distinguish it from stocktoken_quote or stocktoken_find_pools, though it never names those siblings explicitly.

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

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

It provides one conditional rule of use ('If stocktoken_quote.executable is false, do not promise a fill'), which is genuine guidance, but it never states when to reach for this tool versus stocktoken_find_pools or stocktoken_quote. Usage is implied by context rather than spelled out.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered structurally. The description adds genuinely non-derivable context: the registry is the source of truth and only registry addresses are real tokenized stocks, which is a trust/verification semantic an agent cannot get from the annotations. It stops short of describing return shape or whether the registry can change.

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

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

Three short sentences with zero filler: scope first, the trigger condition second, the exclusion third. Every sentence carries distinct information and the most important constraint (trust the registry) is front-loaded.

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

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

No output schema exists, so the description could have said what a listed entry contains (address, symbol, kind) to fully specify the return. It compensates well on scope, safety and alternatives, but the return shape remains implicit for a tool whose whole value is the returned address list.

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

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

Schema description coverage is 100% and the single optional enum parameter (kind) is fully documented in the schema including the default ('all'). The description adds no filter syntax or selection guidance, so baseline 3 applies since the schema does all the work.

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

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

States a specific verb (List) plus the exact resource set (canonical Stock Tokens, ETFs, USDG, WETH) and scopes it to Robinhood Chain 4663. This separates it cleanly from stocktoken_get (single token) and from the quote/price/pool siblings without opening any schema.

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

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

Gives an explicit precondition ('Use this before trusting any address'), an explicit exclusion ('Do NOT use for US brokerage equities') and names the alternative system (Robinhood Trading MCP). Both when-to-use and when-not are stated, leaving nothing to inference.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. However, it only says 'operational metrics' without revealing side effects, permissions, rate limits, or expected output, leaving the tool's behavior largely opaque.

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 short sentence, which is concise but not sufficiently informative. It earns its place but could be improved with more detail without becoming verbose.

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 lack of output schema and annotations, the description should provide enough context about what the tool returns or requires. 'Operational metrics' is too vague, and no information about expected output or usage context is given, making it incomplete for an agent to use confidently.

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

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

The tool has no parameters, and the schema coverage is trivially 100%. The description does not add parameter semantics, but none are needed. Baseline 3 is appropriate.

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

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

The description states it provides 'operational metrics' but does not specify what kind of metrics or what 'process' it refers to. It gives a general sense but lacks specificity to fully distinguish it from other informational tools like stocktoken_get or stocktoken_list.

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

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

No guidance is given on when to use this tool versus its many siblings. There is no mention of appropriate contexts, prerequisites, or alternatives.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It correctly indicates non-custodial operation, the bundled approve and deposit steps, and that no broadcast occurs. This gives the agent critical awareness that the tool only constructs a plan and does not execute it. Missing details include whether the approve action requires prior token approval or if it generates permit signatures, but overall it provides good 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 a single, front-loaded sentence that conveys the core purpose efficiently. It avoids fluff and every phrase adds value. However, the parenthetical '(approve USDG + deposit)' could be slightly clearer (e.g., 'approving USDG and depositing') but remains effective. It strikes a good balance between brevity and information.

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

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

The tool lacks an output schema, so the description should explain the return value (e.g., plan data, transaction request). It does not specify what the plan looks like or how it should be used (e.g., signing and executing). For a plan-building tool requiring subsequent steps, this is a notable gap. Additionally, it doesn't clarify the role of the owner parameter or the approve step's prerequisites, leaving the agent without a complete picture of the workflow.

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 50% (assets and assetsHuman have descriptions, owner and approveMax do not). The description adds no extra parameter meaning beyond the schema. It mentions 'approve USDG + deposit' which relates to assets but fails to explain the role of owner or approveMax (e.g., whether approveMax sets unlimited approval). Given the coverage gap, the description should compensate with parameter clarifications but does not.

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 that the tool builds a non-custodial ERC-4626 deposit plan involving approve and deposit steps into a specific vault (Morpho Steakhouse Earn). This distinguishes it from sibling tools like stocktoken_morpho_withdraw_plan (opposite direction) and stocktoken_execute_plan (which broadcasts). The verb 'Build' and resource 'deposit plan' are specific and 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 explicitly notes 'Does NOT broadcast', informing the agent that this is a plan-building step requiring subsequent execution (likely via stocktoken_execute_plan). It also names the specific vault and operations (approve USDG + deposit), providing clear context for when to use this tool vs. withdraw or subscribe plans. However, it does not explicitly state when not to use it or list alternative approaches, leaving minor ambiguity.

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 provided, so description carries full burden. It correctly identifies the operation as a read (non-destructive) and specifies the chain and balance types. However, it does not disclose error behavior, permissions needed, or rate limits. Adequate but 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?

Single sentence, no filler. Front-loaded with key action and resource. 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?

No output schema exists, so description should hint at return format. It mentions 'share balance and underlying USDG' but does not structure the response (e.g., object with two fields). For a simple read, this is acceptable but incomplete.

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 param description '0x wallet address'. Tool description adds 'a wallet's' which provides context but no new semantics beyond what schema already conveys. 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?

Description clearly states verb 'Read' and specific resources: wallet's Morpho Earn (steakUSDG) share balance and underlying USDG on chain 4663. This distinguishes it from sibling tools like stocktoken_morpho_deposit_plan or stocktoken_morpho_status, which are write or status 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?

No guidance on when to use this tool versus alternatives. It lacks context about when a read is appropriate or how it relates to other Morpho tools. Agent must infer usage from the purpose 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 are provided, so the description carries the full burden. It states the tool returns status information (read-only), but does not disclose any behavioral traits like rate limits, authentication requirements, or response size. Adequate for a simple query.

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 that efficiently conveys the tool's purpose and output. Every word earns its place; there is no unnecessary text.

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

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

For a no-parameter, no-output-schema tool, the description is complete. It specifies the chain, protocol, and exact data points returned (vault address, TVL, share price), leaving no ambiguity about what the tool provides.

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

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

There are zero parameters, so the baseline is 4. The description does not need to add parameter information, and no further detail is required.

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

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

The description clearly states the tool provides status for Morpho/Robinhood Earn on chain 4663, listing specific data (vault address, live TVL, share price). This distinguishes it from sibling tools like stocktoken_morpho_position or deposit plans.

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 siblings. However, the description implies it's for checking the vault's current status, which is a common use case. No exclusions or alternatives are mentioned.

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 the non-broadcast behavior and non-custodial nature, but does not elaborate on permissions, side effects, or return value. The transparency is adequate 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?

Single sentence, front-loaded with verb 'Build', no unnecessary words. Highly concise and efficient.

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

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

Given no output schema and no annotations, the description is adequate but incomplete. It explains the action but does not describe the plan's structure, return format, or next steps. Could be more detailed to fully guide the agent.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies the two modes (withdraw by USDG, redeem by shares) which maps to parameters like assets/assetsHuman and shares/sharesHuman, but does not explicitly map each parameter. Adds moderate value.

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 it builds a non-custodial Morpho Earn withdraw or redeem plan, specifying the actions (withdraw/redeem) and resource (Morpho Earn). It distinguishes from siblings like stocktoken_execute_plan by noting it does not broadcast.

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 it is a preparation step by stating 'Does NOT broadcast', but it does not explicitly provide when to use or alternatives. It hints at the workflow but lacks clear guidance on when to choose this tool over 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?

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses that the tool is optional and redundant on the standard v4 route, but says nothing about what it returns, whether it requires signing, or what happens with the token approval — a notable gap for a prepare-type tool with zero annotation coverage.

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

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

Two tight sentences, zero waste, with the 'optional helper' framing and the routing exclusion front-loaded before any detail. Well sized for the amount of information conveyed.

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 and no annotations, the description should ideally describe the return artifact and any signing/approval prerequisites. It covers when-to-use thoroughly but leaves what the agent gets back and what to do with it unspecified, making the definition only partially 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% — both 'token' and 'permitData' are documented in the schema. The description adds no syntax, format, or normalization detail beyond that, so the baseline 3 applies.

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

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

The description names the resource (Permit2 approval) and its role as a helper, and explicitly distinguishes itself from stocktoken_execute_plan. It is clear enough to route against siblings, though it never states what the tool actually produces (unsigned approval payload vs. typed data).

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

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

It states the exact condition for use ('only when you are assembling a plan by hand') and names the alternative that makes it unnecessary (stocktoken_execute_plan, which already includes the Permit2 approval on a v4 route). No inference is required.

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 should disclose behavioral traits. It only lists the returned fields but does not mention that this is a read-only, safe operation, nor does it address authentication requirements or potential failure modes (e.g., if no policy exists). The description 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 a single sentence that is front-loaded with the main action and lists key details. No extraneous words, making it highly efficient.

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

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

For a zero-parameter retrieval tool with no output schema, the description adequately explains what the tool returns. However, it could mention that the policy is per-agent or that it requires an active session, given the sibling tools imply a complex system.

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, placing the baseline at 4. The description adds value by enumerating the specific policy fields returned, which helps the agent understand the output format even though there is no output 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 specifies exactly what the tool retrieves ('current AI Agent Tokenized Stock OS agent policy') and lists the policy elements (max notional, slippage, simulate-first, kill switch). This clearly distinguishes it from sibling tools like stocktoken_policy_set and stocktoken_get.

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 states what the tool does but provides no explicit guidance on when to use it versus alternatives (e.g., stocktoken_policy_set for modification, other get tools for different data). Usage is implied as a read operation, but no exclusions or context 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?

With no annotations provided, the description alone fails to disclose key behaviors such as side effects, authorization needs, or persistence. It only states the action without behavioral context.

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

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

The description is a single concise sentence that front-loads the action ('Update'). It is appropriately sized but lacks structure for complex details.

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 6 parameters, no output schema, and no annotations, the description is too minimal to provide a complete understanding. It fails to cover key aspects like parameter purposes or return values.

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

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

Schema description coverage is 0%, and the description does not explain any of the 6 parameters (e.g., 'killed', 'allowedSymbols'). The description adds no meaning beyond 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 states the verb 'Update' and the resource 'session policy guardrails', distinguishing it from the sibling 'stocktoken_policy_get' which is likely a getter. However, it could be more specific about what 'guardrails' entails.

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

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

No guidance on when to use this tool versus alternatives like 'stocktoken_session_update' or 'stocktoken_policy_get'. The description lacks explicit context for usage.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description still adds real context beyond them: the price source is a Chainlink oracle, the value includes an ERC-8056 uiMultiplier, and the target chain is fixed at 4663. It stops short of disclosing freshness/staleness or error behavior for an oracle read, so not a 5.

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

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

Three short sentences, zero waste, with the core read operation front-loaded before the exclusions and the alternative. Every sentence carries routing or scope 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?

No output schema exists, so the description must characterize the return, and it does name the two returned values (USD price, uiMultiplier). It does not describe the response shape, decimals, or units, which is a minor remaining gap for a read tool whose safety profile is already covered by annotations.

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

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

Schema description coverage is 100% and the single parameter already documents 'Ticker like NVDA or a 0x registry address'. The description only reinforces that the argument identifies a 'registry token', adding little beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Read) and precisely names the two resources returned (Chainlink USD price and ERC-8056 uiMultiplier), scoped to 'one registry token on chain 4663'. It explicitly distinguishes itself from stocktoken_quote, so an agent can pick it apart from siblings without opening a schema.

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

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

Gives both negative and positive routing: 'This is not a swap quote and not a brokerage quote' and 'Use stocktoken_quote when you need amountOut'. The condition selecting the alternative is explicit, leaving nothing to inference.

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

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

With no annotations, the description carries the full burden. It states what is returned but does not disclose any behavioral traits such as side effects, permissions, or rate limits. It implies a read-only operation, which is expected, but no further detail.

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

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

The description is a single, clear sentence with no redundancy. It front-loads the key action and content, making it efficient 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 zero-parameter tool with no output schema, the description provides sufficient context by listing the specific metadata items returned. It is complete for its simplicity, though it could mention the output type (e.g., addresses, ABI) for extra clarity.

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

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

The tool has no parameters and schema coverage is trivially 100%. The description adds no parameter info, which is acceptable as there are none to document. The baseline of 4 is appropriate.

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

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

The description clearly states the verb 'Return' and the specific resource: metadata for Uniswap Universal Router, PoolManager, WETH, USDG, and feed source on Robinhood Chain 4663. It is distinct from sibling tools that focus on actions like access, execution, or policy 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 does not provide explicit guidance on when to use this tool versus alternatives. While the purpose is clear, there is no mention of prerequisites, context, or when not to use it. It is adequate for a simple query tool but lacks explicit usage 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 adds substantial behavioral context beyond the annotations: it compares 0x, Uniswap API, on-chain Uniswap v3, and hookless v4; returns the route with higher amountOut; falls back to an oracle-indicative result when nothing is executable; requires Pro; and explicitly does not sign or broadcast. This is consistent with the readOnly, idempotent, and non-destructive annotations.

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

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

The description is compact and front-loaded, starting with the core action and chain before covering routing comparison, fallback behavior, access requirement, and safety boundary. Every sentence carries useful information without repetition or filler.

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

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

For a complex multi-source quoting tool with no output schema, the description adequately explains what is returned conceptually: an executable route with the higher amountOut, or an oracle-indicative non-fill result. It also covers Pro access and the no-sign/no-broadcast boundary, though it does not describe the response shape in any further detail.

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 input schema already documents all eight parameters in detail. The description adds no parameter-specific syntax, defaults, or constraints beyond what the schema provides, so the 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 and resource: quote a Stock Token swap on chain 4663. It also explains that the tool compares multiple routing sources and returns an executable route, which distinguishes it from a simple price lookup, but it does not explicitly name or contrast with sibling tools such as stocktoken_price or stocktoken_simulate.

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: this is for obtaining a swap quote before execution, and it notes Pro required and no signing/broadcasting. However, there is no explicit when-to-use versus stocktoken_price, stocktoken_simulate, or stocktoken_execute_plan, and no stated exclusions or prerequisites beyond Pro access.

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 persistence to DATA_DIR and non-custodial nature, which are beyond the schema. But with no annotations, it should describe side effects (e.g., overwrite behavior, auth needs) and doesn't. Adequate but not thorough.

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 action and object. No redundant or filler text. Highly efficient given the needed information.

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

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

With 7 parameters, no annotations, no output schema, the description covers very little. Missing: return value, parameter relationships, error conditions, and usage examples. Incomplete for an agent to use 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 0%, so description must explain parameters. It mentions 'scoped permissions' but gives no details on any of the 7 parameters (owner, ttlHours, sessionKey, permissions, etc.). Completely insufficient.

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 creates a durable agent session with scoped permissions and non-custodial nature. Distinguishes from sibling session tools (kill, list, update) by specifying creation. Lacks full specificity on 'durable'.

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

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

No guidance on when to use this tool versus alternatives. Does not mention prerequisites, context, or excluded scenarios. Only describes what it does, not when 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?

No annotations are provided, so the description must carry full weight. It states 'immediately' and 'kill switch,' hinting at destructive behavior, but does not disclose side effects (e.g., data loss, reversibility, authentication requirements). For a potentially destructive tool, this is insufficient.

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 (one sentence, 6 words) and front-loaded with the core action. However, it sacrifices necessary detail for brevity, so it earns a 4 rather than 5.

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 no annotations, no output schema, and a single parameter with no description, the description fails to provide essential context for a destructive action. The agent cannot determine return format, error handling, or side effects. This is critically incomplete.

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 description provides no information about the 'sessionId' parameter beyond its name. With 0% schema description coverage, the agent must infer from context. No hints on format, source, or validation rules.

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 it kills an agent session immediately. The verb 'kill' and phrase 'kill switch' strongly convey the action. Sibling tools like session_create and session_list indicate this is distinct as the termination 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?

No explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use it, or warn about consequences. The context implies it's for forced termination but lacks explicit direction.

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 provided, so description carries full burden. Only states optional filter; no disclosure of return format, pagination, permissions, or 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?

Single sentence, no unnecessary words. Front-loaded with action and resource. Highly 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?

Simple tool but lacks context about session semantics, response structure, or business logic. No output schema and no annotations necessitate richer description for 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?

One parameter 'owner' with 0% schema description coverage. Description adds that it is an optional filter, which provides some meaning, but does not specify what owner represents (e.g., email, ID).

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 clearly states action (list) and resource (agent sessions), with optional filter by owner. Distinguishes from sibling tools like stocktoken_session_create, kill, update.

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

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

No guidance on when to use this tool vs alternatives (e.g., stocktoken_session_create or stocktoken_session_update). Does not mention when filtering is needed or limitations.

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 bear the full burden. It only states 'Update' implying mutation, but does not disclose authorization needs, side effects, idempotency, or any other behavioral traits.

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, but it is overly minimal for a tool with 5 parameters. It is front-loaded with the purpose but lacks structure or 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?

Given the complexity (5 parameters, no output schema, no annotations), the description is incomplete. It does not explain return values, error conditions, whether updates are additive or replace, or any important context for successful 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 0%, and the description does not add any meaning to parameters beyond their names and types in the schema. For a tool with 5 parameters, more explanation 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 states the verb 'Update' and resource 'limits/permissions on an existing session', distinguishing it from siblings like session_create, session_kill, and session_list.

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

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

No guidance on when to use this tool versus alternatives, prerequisites, or when not to use. The description provides no usage 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?

Annotations already establish readOnly/idempotent/non-destructive, and the description adds real value on top: a tier/auth requirement ('Pro required'), a negative behavioral clarification (it is not an eth_call of the swap), and a conditional action rule. It does not cover latency, rate limits, or full response shape, keeping it short of a 5.

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

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

Three tight sentences, no filler, and the most important constraint (this is a pre-check, not a swap call) is front-loaded before the Pro requirement and the failure-handling rule.

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 partially compensates by naming the key return field ('executable') and prescribing behavior when it is false. It still leaves the rest of the response and several optional session/amount parameters unaddressed, so it is good but not fully self-contained.

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% across all 7 parameters, so the schema already documents tokenIn/tokenOut/notionalUsd/slippageBps and the amount variants. The description only loosely gestures at policy/notional checking and adds no syntax, format, or default detail beyond the schema, which is the expected baseline 3.

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

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

Names a specific operation ('pre-trade check') on a specific chain (4663) and enumerates exactly what it evaluates: allowlist, policy limits, and quote executability. It also explicitly scopes itself against a sibling behavior ('This is not an eth_call of the swap'), so an agent can separate it from stocktoken_quote and stocktoken_execute_plan.

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

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

Gives a clear precondition ('Pro required') and a decisive post-condition ('If executable is false, stop and do not promise a fill'), which tells the agent how to act on the result. It stops short of naming the alternative tools it precedes (e.g., execute_plan or quote) by name, so routing is implied rather than explicit.

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

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

Without annotations, description mentions 'non-custodial' and 'Pays treasury on chain 4663', adding behavioral context. However, it doesn't specify whether the build is a simulation or actual on-chain transaction, required permissions, or side effects like ETH transfer.

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 sentence packs key info: action, resource, non-custodial nature, parameter options, and on-chain behavior. Efficient but slightly dense; could benefit from line breaks 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?

Covers purpose and parameter usage but omits return value, error states, prerequisites (e.g., wallet connection), and relationship to sibling tools. Without output schema, a hint about what the tool returns 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?

Description reinforces schema's parameter hints for tier and ethAmount, but owner (required) lacks any description in schema or text. With schema description coverage at 67%, the description adds marginal value but fails to clarify owner's purpose.

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

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

Description states 'Build non-custodial ETH subscription plan', clearly indicating the action and resource. It distinguishes from siblings like stocktoken_subscription_tiers (which lists tiers) and stocktoken_execute_plan (which executes). However, it doesn't explicitly differentiate from other plan-building tools like stocktoken_morpho_deposit_plan or stocktoken_tip_plan, leaving some ambiguity.

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

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

No guidance on when to use this tool vs. alternatives such as stocktoken_tip_plan or stocktoken_morpho_deposit_plan. It implies usage via tier/custom ETH but doesn't specify context 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?

With no annotations, the description must fully convey behavior. It implies a read-only on-chain query but does not disclose potential side effects (likely none), authentication requirements, rate limits, or failure modes. The deployment note is parametric, not behavioral.

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 no redundancy. However, it could convey more information without becoming verbose, such as clarifying the parameter or return value. It earns a high score for conciseness but not perfect due to missing context.

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

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

Given one parameter and no output schema, the description should explain what 'subscription status' entails, what the returned data looks like, and how the owner parameter is interpreted. The current text is too brief to be fully actionable for an agent.

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

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

Schema coverage is 0%, and the description adds no meaning to the sole parameter 'owner'. It does not specify what the owner represents (wallet address?), its format, or constraints beyond the schema's type string. This is a critical gap.

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

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

The description clearly states the action ('Check on-chain subscription status') and the resource ('for a wallet'). The name 'subscription_status' aligns with this purpose. However, it does not explicitly differentiate from sibling tools like 'stocktoken_subscription_tiers' or 'stocktoken_subscribe_plan', though the verb 'check' implies a read 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?

No guidance on when to use this tool versus alternatives, prerequisites, or exclusions. The parenthetical about SUBSCRIPTION_REGISTRY_ADDRESS is a deployment constraint, not usage guidance. A clearer usage context would improve the 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?

No annotations are provided, so the description carries full burden. It indicates a read-only operation ('List'), but does not disclose authentication needs, return format, or side effects. For a zero-parameter list tool, this is minimally adequate 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 a single sentence with 12 words, front-loading the key action and resource. Every phrase earns its place, with 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?

Given no output schema and no annotations, the description should provide more context about the return structure or prerequisites. It only describes what is listed, not how the listing is presented (e.g., fields, pagination, or data source).

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

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

The input schema has 0 parameters with 100% coverage, so the description need not add param info. However, it adds meaning by specifying the content (on-chain, paid in ETH, no Stripe), which goes beyond the schema. Baseline for 0 params is 4.

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

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

The description clearly states the verb ('List') and resource ('AATOS on-chain subscription tiers'), and adds distinguishing context ('paid in ETH to treasury. No Stripe.'). This differentiates it from sibling tools like stocktoken_subscription_status or stocktoken_subscribe_plan.

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 vs alternatives. The sibling list is large and includes many related tools, so a phrase like 'Use to view available tiers before subscribing' would help, but it's missing.

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 provided, so the description bears full burden. It lists output contents but does not disclose any behavioral traits such as whether the operation is read-only, requires authentication, has rate limits, or is expensive. A read-only status is implied but not explicitly stated. Score 2 for insufficient behavioral disclosure beyond a simple list.

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

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

The description is a single, efficient sentence that front-loads the purpose and lists key output components. Every word earns its place with no redundancy. Score 5 for perfect conciseness.

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 return values more thoroughly. It lists field names (e.g., 'secrets, venues, chain') but not their types or meanings. For a status tool of moderate complexity, this is adequate but not complete. Score 3 as it provides a minimum viable outline.

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 schema coverage is 100% (empty). The description does not need to add parameter meaning. Baseline score of 4 applies because there are no parameters to describe. The description adds value by listing output fields, which is unnecessary for params but harmless. Score 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 it provides 'full system status' and lists specific components (secrets, venues, chain, etc.). It implies aggregation of multiple status aspects, which distinguishes it from more specific sibling tools like stocktoken_fees or stocktoken_price. However, it could explicitly differentiate from other status tools (e.g., stocktoken_access_status). Score 4 for clear verb+resource but slight ambiguity in differentiation.

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

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

No guidance on when to use this tool versus alternatives. Among siblings, there are several status-specific tools (e.g., stocktoken_morpho_status, stocktoken_subscription_status), but the description does not mention when to prefer this comprehensive status over those. Score 2 for no usage context 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 full burden. It does not disclose read-only nature, authentication needs, side effects, or response format. The description is merely informational about acceptance, not behavioral.

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 sentence that is informative and front-loaded. However, it could be more active (e.g., 'List accepted assets'). Still concise 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 no output schema and zero parameters, the description adequately explains what the tool covers. However, it does not specify what the tool returns (list of assets, a confirmation, etc.), leaving some ambiguity.

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

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

There are zero parameters, so the description does not need to compensate for schema gaps. It adds meaning by explaining the tool's purpose, including the optional BTC address nuance, which aids understanding.

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

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

The description clearly states the resource (AATOS tip wallet) and what assets it can accept (native ETH, any ERC-20 on Robinhood Chain 4663, optional BTC). It distinguishes from sibling tools like stocktoken_tip_plan and stocktoken_tip_presets, which deal with tipping plans and presets respectively.

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

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

No guidance on when to use this tool vs alternatives. It does not mention prerequisites, when not to use it, or how it relates to other tipping-related tools.

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

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

No annotations are provided, so the description must disclose all behavioral traits. It only reveals that the tool builds a plan and that user confirmation is needed, but fails to mention side effects (e.g., storage, state changes), permission requirements, or rate limits. For a tool that likely involves financial transactions, this is insufficient.

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 very concise, consisting of two short sentences. The first sentence immediately states the action and resource, followed by a compact list of assets. The second sentence covers amount options and a key behavioral note. No redundant words; every part 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?

Given the tool's complexity (6 parameters, no output schema, financial context), the description is adequate but incomplete. It explains asset options and the amount/preset interplay, but does not describe the plan's return format, how to execute it, or the role of the required 'owner' parameter. It also omits explanation of 'memo' and 'ethAmount'.

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?

With 83% schema description coverage, the schema already documents most parameters. The description adds extra value by stating that 'asset=ETH (default)' (not in schema) and clarifying the relationship between 'amount' and 'preset' (ETH only). It also reminds that the tool should never coerce, which is behavioral but relevant for the 'amount'/'preset' choice.

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 builds an 'OPTIONAL tip plan' and enumerates acceptable assets (ETH, BTC, registry symbols, 0x tokens). It provides the action verb 'Build' and resource 'tip plan', but does not explicitly differentiate from sibling tools like 'stocktoken_execute_plan' or 'stocktoken_tip_presets', missing an opportunity to clarify its role in the workflow.

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 offers some usage guidance: it hints that the plan is optional and requires user confirmation ('User must confirm. Never coerce.'). It also shows example asset formats. However, it lacks a clear statement of when to use this tool versus alternatives (e.g., executing a plan or setting presets), and does not specify prerequisites or conditions for 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 must carry full weight. It discloses the main behavior (listing presets and accepted assets) and notes that tips are never required, implying a read-only, non-destructive nature. However, it lacks detail on authorization needs, side effects, or return format.

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

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

The description is a single concise sentence that efficiently conveys the tool's purpose and a key detail (tips never required). It is front-loaded with the verb and resource, with no unnecessary 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 no parameters or output schema, the description adequately covers the tool's function and a key constraint. It could be slightly improved by clarifying whether presets are user-specific or global, but it is largely complete for a simple list operation.

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

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

There are no parameters (0 params, 100% schema coverage), so the baseline is 4. The description adds value by explaining what the list contains, which is the only relevant information since no parameters exist.

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 tip presets and accepted assets, specifying the verb 'List' and the resources (tip presets, accepted assets). It is specific about asset types (ETH, ERC-20 on 4663, optional BTC), but does not explicitly differentiate from sibling tools like stocktoken_tip_assets.

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 minimal usage guidance, only noting that tips are never required. It does not explain when to use this tool vs alternatives such as stocktoken_tip_assets or stocktoken_tip_plan, nor does it provide context on prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose a non-mutating, read-only nature and rules out quoting/swapping, which is useful, but says nothing about authorization, rate limits, or what the balance read returns.

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

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

Three tight sentences with the purpose front-loaded and the routing note immediately after. No filler, and every sentence adds a distinct piece of information.

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

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

For a simple two-parameter read tool with no output schema, purpose and a key routing rule are covered. The main omission is any explanation of the 'symbols' filter, which leaves the agent guessing at that parameter'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?

Schema coverage is only 50%: 'owner' is documented as a wallet address in the schema, but 'symbols' has no description anywhere. The description never mentions either parameter, so it fails to compensate for the undocumented array filter.

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

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

The description gives a specific verb+resource ('Read balances') and explicitly distinguishes the tool from trading siblings by stating it 'does not quote or swap.' It stops short of a fully self-contained statement of what 'holdings/value' returns, but an agent can place it correctly.

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 supplies an explicit when-not ('does not quote or swap') and names the alternative path ('use stocktoken_quote then stocktoken_execute_plan'). It does not address the other read-oriented siblings (e.g. stocktoken_get, stocktoken_morpho_position), so routing is clear for the trade case only.

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