Crank Protocol

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

Goes well beyond annotations by explaining the exact state transition (pending to approved), the redispatch mechanism via stored tool_name+params, and the failure semantics (stays APPROVED, not EXECUTED or PENDING, can retry). Also notes TTL and non-custodial control plane, all valuable behavioral detail.

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

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

Two dense paragraphs, each sentence adds value: TTL, mode flip, redispatch, failure handling, retry, and a pointer to source. Front-loaded with the core action, 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?

Given the tool's complexity and that an output schema exists, the description is remarkably complete. It covers prerequisites (pending, TTL, propose-mode), side effects (redispatch), failure states, retry guidance, and links to related tools. No critical gaps except optional param semantics, which are secondary.

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 the description must explain parameters. It only implies proposal_id through context and never mentions caller_id or approved_by. The optional params are completely unexplained, leaving the agent to guess their 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?

Clearly states the tool's action: approving a pending PROPOSAL within its TTL and re-dispatching it. Distinguishes from siblings by referencing propose-mode and set_permission_mode, and explains the specific state transition (pending to approved) plus redispatch behavior.

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

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

Provides clear context: use for pending proposals in propose-mode within TTL, and mentions set_permission_mode as related. Also gives retry guidance on redispatch failure. However, it does not explicitly state when not to use or list alternative tools, so not a full 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds: 'Registry-authoritative with a static + symbol fallback' and 'Factual classification only—not a recommendation,' clarifying data sourcing and non-recommendation nature. Slightly lacks detail on response format, but output schema exists.

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

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

The description is concise at ~6 lines, front-loaded with the classification purpose, and well-structured: categories, input, special cases, data source, workflow. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (compliance implications), the description covers purpose, input, special behavior, workflow integration, and pairing. Output schema exists for return values, so no gap. Aids correct agent decision-making fully.

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%; description partially compensates by naming 'token_address (mint)' and 'symbol' and their usage. However, the third parameter 'caller_id' is not explained, leaving a gap. Adds value for two params but incomplete.

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 starts with a clear verb and resource: 'Classify a token' followed by the specific categories, distinguishing it from siblings like get_token_classification. It also details special cases (e.g., tokenized securities as equity), making purpose unambiguous.

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

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

Explicitly states when to use—'RISK/COMPLIANCE step—classify before executing'—and consequences of 'equity' classification (geo-gating + confirm). Also pairs with get_disclaimers and references get_trading_workflow, providing complete 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?

Discloses that passing an empty string for 'assigned_to' unassigns the ticket, which is important behavior beyond annotations. However, does not mention whether assignment overwrites previous, permissions needed, or if notification sent. Annotations already indicate mutability (readOnlyHint=false) and idempotency, so description adds moderate value.

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 with two clear clauses, no redundancy. Front-loaded with the primary action, followed by the special case. Efficient and readable.

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 the core action and the unusual unassignment behavior. Missing explanation of 'caller_id' parameter. Having an output schema reduces the need to describe return values. Overall, adequate for a simple mutation tool but could improve with a brief note on the optional caller_id.

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 clarifies that 'assigned_to' accepts username or id and that empty string unassigns, which adds meaning beyond the schema (which only defines type as string). However, 'caller_id' is not explained, leaving its purpose ambiguous. With 0% schema description coverage, description partially compensates but misses one parameter.

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

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

Clearly states the verb 'assign' and resource 'support ticket' with specific detail about assignment target (staff user via username or id) and special behavior for empty value. Distinguishes from sibling tools like reply_to_ticket and update_ticket_status.

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?

Implies usage for assigning or unassigning tickets, but does not explicitly state when to use this tool versus alternatives such as update_ticket_status or set_ticket_priority. No guidance on prerequisites or when not to 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?

The description adds substantial behavioral context beyond annotations: the non-custodial design, the hard rule that only the public key crosses the call, the trade-only restriction, the gate rejecting certain instructions, and the immediate effectiveness. It also discloses the Lane 2 browser confirmation requirement. No contradiction with annotations.

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

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

The description is dense but every sentence adds value. It starts with the purpose, then explains key parameters and behavioral rules, and ends with an important alternative. The structure is logical and no unnecessary text is present.

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

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

Given the tool's complexity, the description covers the key aspects: what it does, how it works, constraints, alternatives, and the meaning of capabilities/expires_at. An output schema exists, so return values need not be described. The description is sufficient for an agent to select and invoke the tool correctly.

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

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

The description explains the nuanced parameters (signer_pubkey, capabilities, expires_at) with critical rules and defaults, which is valuable given the schema has no descriptions. However, it does not explain wallet_address, label, or caller_id, though these are more standard. Partial compensation for the 0% schema coverage, but not complete.

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

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

The description opens with a specific verb and resource: 'Authorize a delegated session signer for an agent wallet (non-custodial).' This clearly distinguishes it from sibling tools like revoke_session_signer and request_session_signer_authorization, and the subsequent details (signer_pubkey, capabilities, expires_at) reinforce the exact purpose.

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

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

Explicitly states when to use an alternative: 'On a Lane 2 wallet this raises BROWSER_CONFIRMATION_REQUIRED -- call request_session_signer_authorization instead.' It also explains the constraints of the tool (trade-only, gate rules) and the trust-grant nature, giving clear guidance on appropriate vs inappropriate 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?

The description discloses that the tool is read-only, simulates with no fees or on-chain actions, and provides honesty reports for composite strategies. This adds value beyond the annotations (readOnlyHint, destructiveHint) by detailing specific 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 well-structured with a clear purpose, parameter details, and workflow. It front-loads the main idea and contains useful examples. While slightly verbose in listing all 17 strategy types, it remains efficient overall.

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 (13 parameters, output schema exists), the description covers return metrics, honesty reports, slippage models, and workflow. It provides sufficient context for the agent to use the tool correctly without needing the output schema details.

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 0% schema description coverage, the description compensates by explaining most parameters (strategy_type, asset, timeframe, dates, params, slippage_model, etc.) and their defaults. However, a few parameters like caller_id and wallet_address are not detailed, leaving minor gaps.

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

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

The description clearly states the tool's purpose: backtesting a strategy on historical Solana OHLCV before deploying capital. It lists specific strategy types and differentiates this tool from siblings by positioning it as a simulation step.

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

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

The description provides explicit usage guidance: use before deploying capital, run twice for comparison, retune on poor Sharpe. It also references related tools (get_risk_assessment, strategy_*_create) and a workflow, giving clear when-to-use and fallback advice.

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

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

Annotations already indicate non-read-only, destructive, and non-idempotent behavior. The description adds significant operational context: funds are locked into escrow, transactions are unsigned and require manual signing/broadcasting, anti-abuse gates (account age, verified wallet, daily limit), and idempotency replay semantics. No contradiction with annotations.

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

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

The description is well-structured with separate sections for recipients format, flow details, anti-abuse, and idempotency. It is slightly verbose but every sentence adds value. Could be tightened slightly without losing 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 the complexity (7 params, no schema descriptions) and presence of output schema, the description is largely complete. It covers the main flow, idempotency, and constraints. However, it omits explanation of 'referral' and 'caller_id' parameters, and the output schema is not described (though it exists externally). Adequate for most use cases.

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 explain parameters. It explains 'recipients' format in detail (list of dicts with fields), 'token' as a mint, 'sender_wallet', and 'idempotency_key' with UUID example. However, 'referral' and 'caller_id' are not described, leaving a gap. Overall, it compensates well for the missing schema descriptions.

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

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

The description clearly states the tool's purpose: 'Distribute one token to many X handles in one call'. It specifies the non-custodial nature, platform (X), and contrasts with single-send alternatives implicitly. The verb 'distribute' and resource 'many X handles' is specific and distinguishes from sibling tools like send_token_social (single) and get_social_sends (read-only).

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 explains when to use the tool (bulk distribution to multiple handles) and provides details on idempotency for safe retries. It does not explicitly state when not to use it or list alternatives, but the sibling context makes the use case clear. A slight gap is the lack of explicit exclusion criteria.

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

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

Annotations already mark destructiveHint=true, and the description reinforces this with 'Cancel'. It adds valuable specifics: non-custodial nature, geo-gating, idempotency_key replay semantics, and that two-phase execution verification is simpler since no position moves. This goes beyond the structured 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 opens with a concise purpose statement and uses clear paragraph breaks for parameter notes. It is not overly long, though it includes internal ticket IDs (ENG-...) and a cross-reference to place_perp_order that add some noise. Overall, it is well-structured and scannable.

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

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

The description covers critical behavioral nuances (geo-gating, idempotency, two-phase execution) and an output schema exists, so return values are not needed. However, it relies on place_perp_order for key details and leaves several parameters (venue, acknowledge_tier_b, caller_id, ip) undocumented. For this complexity, the description is only partially 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 0%, so the description must compensate. It explains jurisdiction, idempotency_key, and the signed_transaction/verify pair, but leaves wallet_address, order_id, venue, ip, caller_id, and acknowledge_tier_b unexplained. For a 10-parameter tool, this is insufficient even if the complex parameters are covered.

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 first sentence 'Cancel a resting perp order on its venue (non-custodial)' clearly specifies the action, resource, and scope. It distinguishes from sibling tools like perp_close (closing positions) and perp_modify (modifying orders), with 'resting order' making the target unambiguous.

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

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

The description implies usage for canceling a resting perp order but does not explicitly state when to use this tool versus alternatives or provide exclusions. References to 'see place_perp_order' give related context but do not function as direct guidance for tool selection.

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

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

Adds value beyond annotations by noting it's a FREE read, never exposes claim-code secret, and details output fields including live countdown. Consistent with readOnlyHint, idempotentHint.

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

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

Concise two-paragraph format with key info front-loaded. Slightly cryptic first line ('FREE read, ENG-bfeacb2c') but overall 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?

Adequately covers output schema fields and usage constraints for a read operation. No mention of error/edge cases, but output schema provides 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?

Despite 0% schema coverage, description explains claim_id, recipient, and sender_wallet usage. However, it omits caller_id parameter, leaving its purpose unclear.

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 checks claim status of a social send, distinguishing it from sibling 'claim_status' and 'get_social_sends' by specifying lookup methods and output details.

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?

Describes when to use (to check claim status via claim_id or recipient) and optional scoping by sender_wallet, but does not explicitly mention when not to use or contrast with 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?

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) already declare a safe read operation. The description adds value by listing the returned fields (status, amount, claimable, expiry), but no additional behavioral traits are disclosed.

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 efficiently conveys the tool's purpose and output fields. No redundant information.

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

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

Given the presence of annotations and an output schema, the description covers the basic functionality. However, missing details about error conditions or input format reduce completeness for a simple tool.

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

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

Schema has 0% description coverage for parameters. The description only mentions 'claim code' in context, failing to explain the purpose of 'caller_id' parameter or any constraints on 'code' format.

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

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

The description clearly states the tool retrieves the public status of a crank.ing claim code, listing specific fields (status, amount, claimable, expiry). However, it does not differentiate from sibling tool 'check_claim_status', which may cause confusion.

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 provided on when to use this tool vs alternatives, such as 'check_claim_status'. The description lacks context for selection criteria.

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

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

The description reveals side effects: attribution, fee share (15% of tech fee), and cost (free). It clarifies the output is a template, not a deployed strategy. This adds value beyond annotations, which only indicate mutation possibility.

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 concise sentences, front-loaded with purpose, then return value, then fee details. No wasted words.

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

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

The description covers purpose, attribution, and output usage. However, it lacks parameter explanations, which are critical for correct invocation. Given the output schema exists, return value explanation is less necessary, but parameter semantics are still missing.

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

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

The description does not explain any of the three parameters (caller_id, template_id, wallet_address). With 0% schema description coverage, the burden falls on the description, which fails to provide meaning for these inputs.

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 (clone), the resource (published strategy config), and the target (to a wallet). It also mentions it records attribution, which distinguishes it from related tools like strategy creation or copying.

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 tells what to do with the output (use strategy create tools), but does not provide explicit when-to-use vs alternatives or when-not-to-use. Given many strategy-related siblings, more guidance would be helpful.

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?

Beyond annotations marking destruction, description adds essential operational details: unsigned tx return, idempotency replay semantics, geo-gating, and Crank relay/verification. These details are not discoverable from annotations or schema and significantly enhance agent understanding.

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 dense sentences each carry necessary technical context with no filler. The description is front-loaded with the main purpose and then systematically explains special parameters and workflows using reference IDs.

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 core semantics, return type, two-phase workflow, idempotency, and jurisdiction. It leaves a few infrastructure parameters unexplained and does not explicitly compare to overlapping sibling perp_close, but the complexity is substantial and most critical operational context is present.

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

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

With 0% schema coverage, description compensates by defining position_id as venue-native, close_pct range (0,100], plus jurisdiction, idempotency_key, signed_transaction, and verify semantics. However, several parameters (wallet_address, venue, pay_in_crank, payment_header, acknowledge_tier_b) remain undocumented, leaving some gaps.

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?

Opening sentence 'Close a perp position (full/partial) on its venue (non-custodial)' clearly identifies verb, resource, and scope. It distinguishes from open/modify tools but does not address sibling 'perp_close' which appears to overlap.

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

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

Description gives concrete context for two-phase execution via signed_transaction/verify, jurisdiction gating, and idempotency key behavior. It references 'see place_perp_order' for recurring patterns, but does not provide explicit when-not-to-use guidance or alternative selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, establishing safe read-only behavior. The description adds value by confirming 'No persist; read = FREE per the fee schedule' and detailing the validation checks. It also mentions the return of a normalized definition and validation report, providing extra context beyond 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 extremely concise: two sentences and a bullet list, with no redundant words. It front-loads the core purpose and key details, making it easy for an agent to quickly parse.

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

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

Given the tool's complexity (one free-form object parameter), the description covers the essential purpose, behavioral traits, and validation checks. The output schema likely handles return value specifics. It omits details like output format or error handling, but the mention of 'validation report' and existing output schema mitigate this. A mention of example usage context would strengthen it further.

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% description coverage, meaning the single parameter 'definition' is completely undocumented in the schema. The description partially compensates by listing what the tool checks (schema, stream existence, rule-tree limits, risk caps, anti-gaming), implying required aspects of the definition. However, it still lacks explicit structure or required properties for the definition object, leaving ambiguity.

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 'Validate' and the resource 'composite definition'. It specifically says it returns a normalized definition and validation report, and distinguishes itself from sibling creation tools by explicitly stating 'No persist'.

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 context on when to use this tool: to validate a composite definition before creation. It enumerates specific checks (schema, stream existence, rule-tree limits, risk caps, anti-gaming rule), which helps the agent understand its applicability. However, it lacks explicit exclusions or alternatives, such as noting that this should be used prior to strategy_composite_create.

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, etc. The description adds context beyond annotations by specifying that the tool is maintained by the backend dependency response engine and detailing the return fields (RED/AMBER/GREEN, etc.), with no contradiction.

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

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

The description is two sentences long, front-loaded with the tool's purpose, and efficiently lists the return components without wasted words.

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

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

Given the tool has an output schema, the description adequately summarizes the return content. It also mentions maintenance and usage context, making it complete for a tool with one optional parameter and rich 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?

The input schema has one optional parameter (caller_id) with 0% schema description coverage. The tool description does not explain this parameter or its purpose, so it fails to compensate for the coverage 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 returns a protocol dependency compatibility matrix with per-protocol status (RED/AMBER/GREEN) and details like SDK pin, health probe, etc. It uses a specific verb 'returns' and defines the resource, distinguishing it from siblings like crank_prompt_health.

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 usage context by stating it can be called from the morning briefing, dispatch, or ad-hoc. However, it does not explicitly say when not to use it or compare with alternatives, which would make it a 5.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds that the tool returns trend data per issue and that 'available=False' until the first weekly review runs, providing useful behavioral context beyond 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 reasonably concise with 4-5 sentences, front-loading the purpose. It includes a snapshot ID and context, which is useful but slightly verbose. It could be more succinct without losing 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 the tool has an output schema and is read-only, the description sufficiently explains the return format (headline + per-issue trend) and availability condition. It covers the necessary context for an agent to decide when to call this tool.

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

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

The schema has one optional parameter 'caller_id' with 0% schema description coverage, but the description does not explain its purpose or usage. The description fails to add meaning for the parameter, which is critical given the low schema coverage.

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

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

The description clearly states 'Dev Process Health — recurring CC friction this week vs resolved' and specifies it returns a weekly close-report review snapshot with a headline and per-issue trend. It distinguishes from many sibling tools focused on other health metrics like 'crank_dependency_status' or 'get_venue_health'.

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

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

The description notes it is read-only and surfaced in the Monday morning briefing, suggesting a specific use context. However, it does not explicitly state when to avoid using it or offer alternatives, leaving some 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?

Annotations already indicate this is not read-only, not idempotent, and not destructive. The description adds valuable behavior beyond that: it creates a record, optionally applies policy presets, and can create a pending record for a Turnkey provisioning ticket to fill. It also discloses the return fields, which is useful context. No contradictions with annotations.

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

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

The description is concise and well-structured: first sentence states the core purpose, second explains how the record is created and key parameters, third lists return values. Every sentence adds value with no fluff, and it is front-loaded with the most important information.

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

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

For a tool with 6 parameters and an output schema, the description covers the core mechanics (keyed by agent_id, policy presets, pending record flow) and return values. It does not explicitly explain how this relates to sibling lifecycle tools like enable_agent_wallet, but the context provided is sufficient for most use cases.

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 the description carries the burden. It does explain the semantics of default_policies (conservative | balanced | aggressive) and wallet_address (public key, optional, pending record behavior). However, it does not clarify agent_id, caller_id, display_name, or owner_address, leaving half the parameters under-explained.

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 begins with 'Register an agent wallet the caller controls (non-custodial control plane)', which is a specific verb+resource statement. It clearly distinguishes this from sibling tools like enable_agent_wallet, kill_wallet, and wallet_status by focusing on registration and creating an AgentWallet record keyed by agent_id.

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

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

The description provides clear context for when to use the tool — registering an agent wallet in a non-custodial control plane. It explains conditional usage (omit wallet_address for pending records) but does not explicitly name alternatives or exclusion criteria relative to sibling wallet tools, so it stops slightly short of a 5.

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

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

The description adds substantial behavioral context beyond annotations: 'This tool never signs and never sees a key' and 'NOTHING executes until user approval.' It also instructs to 'report ONLY the persisted on-chain state (CONFIRMED before any success claim),' preventing premature success reporting. These safety-critical details are consistent with the mutation/destructive annotations and significantly aid correct invocation.

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 core behavior is front-loaded in the first sentence, and the description uses clear section headers (Lane 1, FEE PARITY, GEO GATE). Yet it contains verbose internal engineering references (ENG-8f3fb6d6, follow-up to ENG-254cf6b4/ENG-5a051af4) and lengthy justification for exposing pay_in_crank that could be condensed without losing essential guidance.

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

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

The description covers the full lifecycle: proposal creation, approval URL, polling get_intent_status, and confirmation state. It comprehensively addresses fee parity and regulatory geo-gating, which are essential for this complex tool. Since an output schema exists, it doesn't need to detail the full return structure, though it could mention more parameter edge cases or error handling.

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 0% schema description coverage, the description must compensate, and it does for critical parameters: 'amount is in input-token base units,' pay_in_crank's fee-discount role is explained, and jurisdiction/ip are detailed for geo-gating. However, it leaves several parameters (e.g., slippage_bps, allow_unverified, idempotency_key) unexplained, so the compensation is incomplete.

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

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

The description opens with 'Create a propose-only execution intent; returns an approval URL to hand to the user,' clearly stating the tool's action and output. It further distinguishes itself from direct-swap siblings like jupiter_swap by emphasizing the propose-only, non-custodial nature.

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 identifies this as 'Lane 1 (non-custodial default)' and explains that 'NOTHING executes until the user opens the approval URL... signs with their own wallet,' providing clear context for when to use this tool over an immediate-execution swap. It also references jupiter_swap and trade_equity for shared geo-gating and fee-parity controls. However, it does not explicitly state an alternative like 'use jupiter_swap when direct execution 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?

Even with annotations already providing idempotency and non-destructiveness hints, the description adds crucial context: the declaration is remembered for 90 days, overwrites prior values, is self-declared (never advice), and changes the DENIED reason. It also clarifies that it's a write operation, consistent with readOnlyHint=false, with no contradiction.

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

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

The description is relatively long but front-loaded with the core purpose. Every sentence adds value, though the internal gap reference (RAILS-4) and detailed regulatory framing add density. It earns its length for the complexity, but could be slightly tightened.

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?

Context is rich: why the tool exists, when it's needed, how it behaves over time, regulatory limitations, and the alternative path. With an output schema present, return values are covered elsewhere. The description is complete for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the key jurisdiction parameter (ISO-3166-1 alpha-2, examples, self-declaration), but leaves wallet_address, ip, and caller_id to be inferred. Given the critical parameter is well covered, this is strong, though not perfect.

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

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

The description opens with a specific verb and resource: 'Declare your wallet's jurisdiction for geo-gated trading.' It clearly identifies the tool's function and distinguishes it from siblings by referencing the alternative jurisdiction= param on trade_equity, making the purpose unmistakable.

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

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

Explicitly states when to use this tool vs alternatives: 'Call this ONCE (or pass jurisdiction= directly on any perps/short/leverage/trade_equity tool).' It also gives exclusions, noting that a US-person declaration does not unblock US-restricted venues, and explains the fail-safe rule this tool addresses.

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 indicate a write operation (readOnlyHint=false) and openWorldHint=true. Description adds 'free control-plane write' but fails to disclose side effects, reversibility, or error states. For a destructive action, more context is expected beyond the annotations.

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

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

Extremely concise (one phrase). It is front-loaded with the action, but lacks structure and depth. The brevity sacrifices useful details without achieving meaningful 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?

The tool has 3 parameters and an output schema, but the description provides minimal context. It does not address required parameters, error handling, or success behavior. The existence of an output schema reduces the need for return value explanation, but the description still needs to cover usage prerequisites and typical outcomes.

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 0% schema description coverage, the description should explain parameter meanings. It does not mention wallet_address, webhook_id, or caller_id. While parameter names are somewhat intuitive, format or constraints are omitted.

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 (delete), resource (webhook subscriptions), and scope (one of a wallet's). It distinguishes from siblings like register_webhook and list_webhooks, providing a specific verb+resource combination.

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

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

The phrase 'free control-plane write' hints at low cost but does not explicitly state when to use this tool versus alternatives like register_webhook or list_webhooks. No guidance on prerequisites or when not to 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?

The description goes well beyond the annotations by explaining that the tool is deterministic, returns raw indicator values for transparency, and makes no on-chain actions or fees. It also includes an explicit disclaimer that it provides "a suggestion only -- not financial advice, not a trade instruction (DYOR)." These details add behavioral context not captured in the readOnlyHint/idempotentHint/destructiveHint annotations, giving the agent a clear picture of the tool's side-effect profile.

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

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

The description is longer than average but every sentence adds value: it front-loads the core purpose, succinctly explains the output and parameters, notes limitations, and gives workflow context. It is well-structured with clear paragraphs and no filler. The length is justified by the tool's complexity and the need to disclaim financial advice.

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

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

The description is remarkably complete given the tool's complexity. It covers the input (asset and timeframe), the output (RegimeSignal fields and raw readings), the operational context (INTELLIGENCE step, pairing with other tools), and the boundaries (read-only, no on-chain action). Since an output schema exists, the description need not repeat return types, but it still provides enough detail to use the tool correctly.

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

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

With schema_description_coverage at 0%, the description must compensate for missing parameter details. It explains that "asset is a token mint" and lists valid timeframe values ("1m/5m/15m/1h/4h/1d"), which adds meaning beyond the bare schema types. However, it does not describe lookback_candles or caller_id at all. Since half of the parameters are undocumented in the description, the compensation is incomplete, resulting in a mid-range score.

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

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

The description clearly states the tool's purpose with a specific verb and resource: "Detect the current market regime for a Solana asset." It also distinguishes itself from similar tools by detailing its unique output (RegimeSignal, ADX, +DI/-DI, etc.) and by referencing sibling tools like get_market_briefing and get_ml_signal as complementary, not replacements. The read-only and deterministic nature is also highlighted.

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

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

The description provides explicit workflow guidance: "pair with get_market_briefing (macro) + get_ml_signal (forecast)" and states that it feeds strategy choice and direction_mode. It also gives a concrete usage example: "bear + allow_short -> consider a short." It clearly positions itself within the INTELLIGENCE step and even references get_trading_workflow for further context, making when to use this tool unambiguous relative to 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?

Matches annotations (read-only, idempotent) and adds 'free' and ranking details. Does not contradict annotations.

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

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

Very concise (3 lines), front-loads purpose, and well-structured without unnecessary words.

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

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

Covers purpose, filtering, ranking, and read-only nature. Has output schema and rich annotations, so missing param explanations for limit and caller_id are minor gaps.

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

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

Schema coverage is 0%, but description only explains the capability parameter with a list of values. No details on limit or caller_id, insufficient compensation for low coverage.

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

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

The description clearly states 'Find registered agents, optionally filtered to one capability,' with a specific verb and resource. It lists valid capabilities and distinguishes this from sibling tools like discover_strategies.

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

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

Provides explicit context on filtering (capability list, empty = all) and ranking (by reputation then recency). Lacks explicit when-not or alternatives but is adequate for agent discovery 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 declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds 'free' and 'crypto-only' constraints, but does not elaborate on other behaviors like pagination 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?

Two concise sentences, front-loaded with purpose and constraints, efficient use of space.

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?

Output schema exists, but description lacks details on limit and caller_id parameters. Assumes knowledge of 16 Crank types. Overall adequate for a browsing tool but with gaps.

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

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

Schema coverage is 0%, so description must compensate. It explains strategy_type filters to 16 types and sort options with valid values, but does not describe limit or caller_id parameters.

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

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

The description clearly states 'Browse published strategies' with verb and resource, and adds constraints 'read-only, free, crypto-only'. However, it does not explicitly distinguish from sibling tools like strategy_list or get_leaderboard.

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 when not to use it or compare with 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?

Annotations provide basic hints (readOnly false, openWorld true), but the description adds critical behavioral context: returns a pairing URL + device_code, requires wallet-signature gated approval in the user's own browser, forbids accepting in-chat consent, and references a spec section. These details go well beyond annotations and disclose the sensitive confirmation workflow.

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

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

The description is three sentences, front-loaded with the primary action. It then packs essential safety and next-step information without redundancy. Every sentence earns its place, making it efficient and well-structured.

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?

An output schema exists, so return values are handled externally. The description covers the workflow (open handshake, show URL, require user approval, poll until done) and safety constraints. The only notable gap is the missing explanation of optional parameters (caller_id, display_name), which prevents full 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?

Schema description coverage is 0% (no parameter descriptions). The description does not explain the three input parameters: agent_id, caller_id, and display_name. While agent_id is inferable as the target wallet, caller_id and display_name remain ambiguous, forcing the agent to guess their purpose. The description fails to compensate for the schema's lack of parameter documentation.

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: 'Open the browser-confirmation handshake for a Lane 2 agent wallet.' It explicitly differentiates from related tools by saying 'Does NOT create a wallet,' and specifies the output (pairing-style confirmation URL + device_code). This is a specific verb+resource with clear sibling distinction.

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

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

The description provides explicit when-to-use guidance: it's for enabling an agent wallet via browser confirmation, not for creation. It instructs to poll with poll_agent_wallet_enable(device_code) until status changes, and provides strong constraints (ask user to approve in their own browser, never accept in-chat 'yes'). This is actionable and contrasts with 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the tool is provider-backed and returns an honest empty payload with an SEC EDGAR link when no feed is configured, which is valuable behavioral context beyond the annotations.

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

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

The description is three concise sentences with no wasted words. The core purpose is front-loaded in the first sentence, making it immediately clear.

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 existence of an output schema and annotations, the description adequately covers the tool's behavior, including the empty payload case. It mentions tokenized equity and the Solana context, though it omits details on calendar field contents, which may be in the output schema.

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

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

With schema description coverage at 0%, the description must compensate for the two parameters (symbol, caller_id) but provides no explanation of their meaning or usage. The schema alone does not clarify 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?

The description clearly states the tool provides an earnings/dividend/split calendar for a tokenized equity, with a specific verb+resource. It distinguishes itself from siblings like equity_quote and equity_positions by focusing on corporate events.

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

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

The description implies usage for overnight strategies via the 'after-hours-agent feature' but does not explicitly state when to use this tool over alternatives or when not to use it. No exclusions or comparisons 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. The description adds that it returns next open/close times and highlights the 24/7 trading advantage, which provides useful behavioral context beyond 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 brief at two sentences, but the final sentence about structural advantage is promotional and adds no technical guidance. It could be trimmed to only essential 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?

While the description covers the output status values and next open/close behavior, it does not explain how the symbol parameter affects the results or how the availability flag is represented. Given the existence of an output schema, the description is moderately complete but has gaps.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the input schema. The tool description does not mention the parameters (symbol, caller_id) or explain their role, failing to compensate for the schema's lack of detail.

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

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

The description clearly states the tool provides NYSE session status and a 24/7-on-Solana availability flag. It lists possible status values (closed, pre_market, open, after_hours) and mentions next open/close times, making the purpose specific and actionable.

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 siblings like equity_markets. The description does not specify when not to use it or which alternative might be better for related 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds valuable context: source (admin-editable TokenRegistry), data quality ('best-effort' for prices), and special flags (NYSE status, 24/7-on-Solana). No contradictions with annotations.

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

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

Three sentences, each adding value: first defines action and output, second adds source context, third enumerates fields. No redundancy or fluff.

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

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

The description covers source, data quality, and key fields. Given an output schema exists and the parameter is optional, this is nearly complete. Minor gap: no explanation of caller_id, but overall adequate for a list 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 has one optional parameter (caller_id) with 0% description coverage. The description does not mention this parameter or its purpose, leaving the agent without guidance on when or why to provide it.

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

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

The description clearly states 'List available tokenized equities' with specific fields (issuer, price, market hours, etc.), which distinguishes it from siblings like equity_quote or equity_positions. The verb 'list' and resource 'tokenized equities' are unambiguous.

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

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

The description implies usage for reading tokenized equity listings but does not explicitly state when to use it vs alternatives or provide exclusions. Context suggests it's the go-to for a catalog, but lacks explicit guidance.

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

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

Beyond annotations (readOnlyHint=true, idempotentHint=true), the description adds details about return fields (symbol, quantity, current_price, etc.) and notes that avg_cost/unrealized P&L are null until cost-basis tracking lands. No contradictions.

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: first states core purpose, second adds key details. No extraneous information. Efficient and well-structured.

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

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

Given the tool's simplicity and the presence of an output schema, the description covers all necessary aspects: read-only behavior, filtering, fields, and a caveat about missing P&L. Complete for its complexity.

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

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

Schema description coverage is 0%, and the description does not explain the parameters beyond implying wallet_address is needed. caller_id has no explanation. The description should add meaning, but it doesn't compensate for the missing schema descriptions.

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

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

The description clearly states 'Tokenized-equity holdings for a wallet with live prices + market hours,' specifying a verb (holdings) and resource. It distinguishes from sibling tools like equity_quote or equity_corporate_events by focusing on holdings with live 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?

The description explicitly notes 'Read-only' and 'Filters balances to registered equity mints,' providing clear context. It doesn't name alternatives or exclusions, but the purpose is sufficiently clear for selecting this tool over others.

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

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

The description discloses behavioral traits beyond annotations: amounts are in base units, returns specific fields (expected output, price impact, etc.), and venue_hint is advisory. No contradictions with annotations.

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

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

The description is three sentences, front-loading the core purpose. Every sentence adds value without redundancy.

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

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

Given annotations and output schema, the description covers key aspects (read-only nature, parameter semantics, return fields) and references the execution sibling. Lacks full parameter documentation but otherwise 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?

With 0% schema coverage, the description explains amount and venue_hint but leaves side, symbol, caller_id, and slippage_bps undocumented. Partial compensation but insufficient for all parameters.

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

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

The description clearly states 'Read-only Jupiter quote for a tokenized-equity trade (no execution).' This provides a specific verb (quote), resource (tokenized-equity), and scope (read-only/no execution), distinguishing it from sibling tools like trade_equity.

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 explains that the tool is for quotes only and directs to trade_equity for execution, providing usage context. However, it could more explicitly state when not to use this tool.

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

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

The description adds critical behavioral details beyond annotations: returns an unsigned base64 tx that reverts unless repaid, authenticity verification, idempotency key replay behavior, and destructive nature (consistent with destructiveHint=true).

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

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

The description is reasonably concise with key points front-loaded. The idempotency_key detail could be integrated more smoothly, but overall it's well-structured and not 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?

The description explains the return type, flow, and key behaviors; given the output schema exists, return details are not needed. It covers atomicity, authentication, and retry behavior, but could mention prerequisites like wallet funding.

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?

While schema coverage is 0%, the description explains idempotency_key, allow_unverified, and instructions. However, it omits caller_id, pay_in_crank, payment_header, and basic parameters like token and amount are only implied, leaving gaps.

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 'Marginfi flash loan for arbitrage (non-custodial, atomic)' with a specific verb and resource, distinguishing it from other lending or swap tools in the sibling list.

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

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

The description provides context for use (arbitrage) and mentions conditions like allow_unverified and daily free tier with payment_header, but does not explicitly state when not to use this tool or compare to alternatives like lend_borrow.

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

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

The description discloses the non-custodial nature, direct settlement to wallet_address, and the fee structure (charged on amount_usd notional past daily free tier). It also details idempotency_key behavior. Annotations indicate destructiveHint true, which is consistent. No contradiction found except a minor nuance with idempotentHint.

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

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

The description is well-structured with three paragraphs: main purpose and return values, details on flow and fees, and idempotency_key behavior. It is front-loaded with the essential information. Could be slightly more concise, but it's clear and specific.

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 8 parameters and an output schema, the description covers the main flow and key parameters but omits details on caller_id and pay_in_crank. It does not explain error handling, rate limits, or prerequisites (e.g., wallet existence). Given the tool's complexity and the availability of annotations, it is somewhat complete but has gaps.

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

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

The description adds meaning beyond the schema for idempotency_key (explains replay behavior) and payment_method (lists enum values not in schema). Other parameters like wallet_address and amount_usd are implicit. However, caller_id, pay_in_crank, and payment_header are not described, leaving gaps despite schema coverage being 0%. The description compensates partially.

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

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

The description clearly states the tool's purpose: 'Fund a wallet with fiat via MoonPay (card/bank/Apple Pay -> USDC).' It specifies the flow (returns checkout_url and session_id), the asset (USDC), and the payment methods. This distinguishes it from siblings like offramp_to_fiat.

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 explains the tool's output (checkout_url, session_id) and how to use them ('poll with get_onramp_status'). It implies the use case of onramping fiat to USDC, contrasting with offramp. While it does not explicitly list when not to use or alternatives, the context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the 'free' attribute and specifies the data returned (profile + referral stats), providing value beyond the annotations.

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

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

A single sentence that conveys the tool's essence with no extraneous words. 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?

The tool is a simple read operation with 2 parameters and an output schema. The description is complete for the purpose but lacks parameter documentation, which is a notable 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?

With 0% schema description coverage and no parameter information in the description, the agent must infer from parameter names. The description adds no meaning beyond the schema, failing to compensate for the coverage 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 uses the specific verb 'Read' and identifies the resources 'published profile' and 'referral stats'. It clearly distinguishes from sibling tools like 'update_agent_profile' and other read tools.

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

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

The description includes 'read-only, free' which implies when to use (read operations, no cost) but does not explicitly state when not to use or mention alternatives. The context is clear enough for an agent.

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, and destructiveHint, and the description adds 'Read-only' which aligns. It also discloses the return content (health records with specific fields) and the purpose for routing decisions. No contradictions with annotations. Additional details about authentication or rate limits are not needed given the safe nature.

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

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

The description is short (three sentences) and front-loaded with the core purpose. The second sentence lists return fields, but the third sentence repeats the purpose slightly. No significant fluff, but could be more streamlined by merging the first and third sentences.

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

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

Given the existence of an output schema, the description provides a useful summary of the key data fields and the decision-making context. It does not need to detail return format, but it could explain how the composite safety score is derived or how to interpret the data. Still, for a dashboard overview, it is sufficiently complete.

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

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

Schema description coverage is 0%, meaning no explanations in the schema. The description does not mention the single optional parameter 'caller_id' at all, leaving the agent to guess its purpose. While the parameter has a default and is likely optional context, the lack of any guidance reduces clarity.

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

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

The description clearly states it provides a dashboard overview of all configured venues for routing decisions, specifying it returns one health record per active venue with fields like status, deploy slot, TVL, 24h volume, and composite safety score. This distinguishes it from sibling tools like get_venue_status which likely focus on single venues.

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 says 'so an agent can pick a venue in a single call', indicating the primary use case for venue selection. However, it does not explicitly state when not to use this tool or mention alternative tools for specific venue details, though the context of sibling tools implies such differentiation.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, etc. The description adds valuable behavioral context: the data is 'already-debounced' requiring consecutive polls, and is 'decision-support only.' No contradictions with annotations.

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

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

The description is front-loaded with the core purpose, followed by concise technical details, disclaimers, and workflow integration. Every sentence adds value without redundancy or fluff.

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

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

Given that an output schema exists (not shown), the description need not detail return values. It explains episode content (venue pair, spread, times, reference price), limitations, and integration with a sibling tool. Combined with annotations, this provides a complete picture.

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 explain parameters. It mentions 'assets,' 'min_spread_bps,' and 'window_hours' with clear semantics. However, 'caller_id' is not referenced. Despite this omission, the description provides sufficient meaning for the majority of parameters.

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

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

The description clearly defines the tool as retrieving 'Persisted cross-venue discrepancy episodes (free read),' explicitly distinguishing it from the sibling 'get_cross_exchange' by noting it is persisted and debounced versus a 'current live-ish read.' The verb 'get' and resource 'arb discrepancies' 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 provides explicit usage guidance: it is an 'INTELLIGENCE step' to be paired with 'get_cross_exchange' for live reads. It also states limitations ('ignores fees, slippage, and transfer latency; never an execution instruction'), clearly defining when not to use the tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering safety and idempotency. The description adds no further behavioral traits, but it is consistent and provides minimal extra value beyond 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 extremely concise: two short sentences. The first defines purpose, the second provides workflow guidance. No wasted words.

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

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

Given the simple tool (2 parameters, output schema exists), the description covers purpose and workflow context. It does not detail output structure, but the output schema handles that. Overall, it is sufficiently complete for safe and correct invocation.

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

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

Schema description coverage is 0% (no descriptions in schema). The description only implicitly explains 'wallet_address' via the tool's purpose, but it does not mention 'caller_id' at all. This leaves the agent without full parameter meaning, failing to compensate for the missing schema descriptions.

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

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

The description clearly states the tool retrieves wallet token balances for SOL and all SPL tokens with USD valuations. It explicitly calls out the resource (wallet token balances) and the specific scope (SOL + SPL), making it distinct from siblings.

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

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

The description provides explicit guidance: 'Workflow: ORIENT step -- the starting read for any flow. See get_trading_workflow.' This tells the agent when to use this tool (as an initial orientation step) and points to an alternative for trading workflows.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior, but the description adds substantial behavioral context: only active/non-suppressed/non-expired insights are returned, the meaning of epsilon_spent (weigh high-epsilon insights cautiously), staleness interpretation, and a clear disclaimer that responses are descriptive only. This goes well beyond the annotation hints, providing genuine transparency about data filtering and interpretation.

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

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

The description is dense but well-structured: a one-line summary, then filters, then return-field semantics, then a workflow note. Every sentence adds value—no fluff or repetition. It is front-loaded with the core purpose and uses paragraphs to separate concerns, making it easy to scan.

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

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

Given the tool's analytical complexity, the description covers all essential aspects: filters, data fields, privacy metadata caveats, staleness, and workflow integration. With an output schema present, the return structure is already documented, so the description need not explain every field. It compensates for the empty schema descriptions and provides enough context for an agent to select and invoke this tool appropriately.

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 0% schema description coverage, the description carries the parameter documentation burden. It explains asset (mint/symbol), strategy_type, insight_type (with an explicit list of allowed values), and detail (concise vs full modes with what each adds). The only unmeasured parameter is caller_id, which is not described. This is a strong compensation but not complete, hence a 4.

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

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

The description opens with a precise summary: 'Fleet-wide collective insights, historical performance data (free read).' It clearly identifies the tool's function (retrieving collective insights) and scope (fleet-wide, aggregated across the Crank agent fleet), distinguishing it from sibling tools like get_market_briefing or get_consensus. The explicit mention of 'historical performance data' and 'descriptive only' further clarifies its purpose.

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

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

The 'Workflow: INTELLIGENCE step' line provides clear guidance on when to use this tool—alongside get_market_briefing and get_consensus before sizing or creating strategies. It also warns that insights are 'never a recommendation or a promise of results.' However, it does not explicitly state when NOT to use this tool or how it compares to alternatives, so it falls short of a full 5.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. The description reinforces these by stating 'Descriptive signal only, not a recommendation' and 'Not financial advice.' It adds billing context and explains the consensus score range, exceeding what annotations alone provide.

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

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

The description is front-loaded with the purpose in the first sentence, followed by detailed explanation and a clear workflow section. No redundant sentences; each adds value. Length is appropriate for the complexity.

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 5-parameter tool with 0% schema coverage and no output schema details, the description provides comprehensive context: premium tier, billing, consensus scoring ranges, source breakdown, and workflow pairing. It is fully complete for an agent to understand usage.

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

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

With 0% schema description coverage, the description carries the burden. It effectively explains 'asset', 'window_hours' (with default 24), and mentions 'payment_header' for billing. However, 'caller_id' and 'wallet_address' are not explained, leaving some ambiguity. Still, the main parameters are well-covered.

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 first sentence clearly states the verb 'get', the resource 'multi-source consensus + contrarian read for one asset', and distinguishes from siblings by specifying 'PLATINUM premium' and the 'INTELLIGENCE step' workflow context. It is specific and unique.

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

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

The description provides explicit guidance: 'Workflow: INTELLIGENCE step -- pair with get_market_briefing + get_source_accuracy to gauge how crowded a directional read is before sizing.' It also explains premium tier and payment process, telling the agent when this tool is 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, destructiveHint false. The description adds behavioral details: scans over window_hours, returns assets with high/low agreement, billing outcome in 'billing', and states it's not a recommendation. No contradiction with annotations.

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

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

The description is front-loaded with the main purpose and includes necessary details (billing, disclaimer). It is organized but slightly long. Each sentence adds value, though some could be more 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?

Covers main functionality and billing context, but missing descriptions for caller_id and wallet_address parameters. With 0% schema coverage, more detail is needed for full understanding. Output schema exists but is not shown, so return values are partially explained.

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 description must compensate. It explains window_hours (time window), asset (filters to one asset), and payment_header (via x402 payment). However, it does not describe caller_id or wallet_address, leaving gaps.

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 scans for contrarian (crowded) and uncertain assets based on source agreement, with a specific verb 'scans' and resource 'classified intelligence signals'. It distinguishes itself by mentioning 'PLATINUM premium' and 'contrarian' vs. other signal tools, but does not explicitly differentiate from siblings like get_signals or get_ml_signal.

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

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

Provides context: 'Workflow: INTELLIGENCE step -- surface crowded trades to fade or uncertain assets to avoid before committing to a regime/allocation.' This implies when to use it (before committing) and that it's descriptive only. However, it lacks explicit exclusions or alternative tools.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive. The description adds valuable context: explains sybil_flagged + penalty_bps, score accrual from on-platform activity, and circular funding detection. No contradictions.

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

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

Description is well-structured with a clear purpose sentence followed by detailed return fields and behavioral notes. Slightly longer than necessary but remains focused and informative.

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

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

Given the presence of an output schema (not shown) and comprehensive annotations, the description covers all necessary context: return structure, sybil penalty, score accrual mechanism, and the free read nature. Sufficient for correct tool 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 has 0% description coverage for parameters. The description does not explain caller_id or wallet_address beyond their existence. It only implies that wallet_address is the input, leaving agents to infer the meaning of the optional caller_id parameter.

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

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

The description clearly states the tool returns a wallet's Crank Score reputation breakdown, including specific components like total_score, per-activity components, sybil_flagged, and gates. It distinguishes from sibling tools by focusing on the 'Crank' score variant.

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 other score tools like get_score or get_score_leaderboard. The phrase 'FREE read' implies it's safe to call, but no when-to-use or alternative recommendations.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds important caveats: spreads ignore fees/slippage/latency, data is 'decision-support only', and the tool is a 'free read'. No contradictions with annotations.

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

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

The description is front-loaded with the summary sentence, then a bullet-like list of data fields, and ends with a workflow tip. Every sentence adds value; no fluff. Appropriately sized for the tool's complexity.

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 output schema exists and the tool is relatively simple, the description provides enough context for the agent to understand the tool's purpose and limitations. However, the lack of parameter explanations (especially for window_minutes) slightly reduces completeness, as the agent may not know how to correctly set the time window.

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% (no parameter descriptions). The description fails to explain the parameters: 'asset' is implied but not explicitly defined, 'window_minutes' is not connected to the listed movement windows (5m/1h/24h), and 'caller_id' is completely unaddressed. The description relies on common sense but does not add sufficient meaning beyond parameter names.

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

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

The description clearly states it provides a 'Cross-venue snapshot for one asset (free read)' and lists specific data points (price/bid/ask/movement, spread matrix, wrapped-asset premium). It distinguishes from sibling tools by noting pairing with get_arb_discrepancies for episode history.

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 frames it as an 'INTELLIGENCE step', advises pairing with get_arb_discrepancies, and warns against using as execution instruction or financial advice. These guidelines help an agent decide when to use this tool versus 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?

Annotations already declare read-only, idempotent, and open-world behavior. The description adds context about the SEC framework, asset classification, and a separate notice for equity, which improves transparency beyond the annotations.

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

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

Three efficient sentences with clear front-loading of purpose, followed by input options and a reference to full text. No unnecessary words.

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

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

For a simple read-only tool with an output schema, the description covers the core functionality and input options adequately. The only missing detail is the purpose of caller_id, but overall it is 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?

With 0% schema description coverage, the description compensates by explaining the main parameters: asset_classification (with enumerated values) and token_address/symbol for classification. The caller_id parameter is omitted, leaving a minor 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 it retrieves compliance disclaimers for an asset class under the SEC framework. It specifies accepted asset classifications and alternative identifier inputs, distinguishing it from sibling tools.

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

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

The description explains when to use the tool: to get disclaimers for an asset. It provides guidance on input options (asset_classification vs. token_address/symbol) and notes a special case for equity. However, it does not explicitly contrast with alternatives among 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?

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false), the description adds meaningful behavioral context: 'k-anonymous', 'No wallet address or cohort key is ever returned', 'differentially-private aggregate effect_size', and 'never a recommendation or a promise of results.' It also discloses the limit cap (max 100) and the minimum cohort threshold (10), giving the agent a solid understanding of what to expect.

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

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

The description is front-loaded with the core definition, followed by details on output fields, parameters, privacy, and workflow. Every sentence adds value—no filler or repetition. It is slightly long but appropriately so for a tool with these nuances, and the structure makes it easy to scan.

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

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

Given the tool's moderate complexity, this description is thorough. It covers what the tool returns, the anonymity guarantee, differential privacy, output fields (n_agents, effect_size, confidence interval, epsilon_spent, staleness), parameter filtering, the workflow context, and a disclaimer. The presence of an output schema means return values don't need to be fully restated, but the description enriches the schema by explaining the semantics of the motifs and the 'no existing strategy type' condition.

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 the description must compensate. It does explain the two main parameters: 'Filter with min_agents; limit caps the result count (max 100).' However, caller_id is not mentioned at all, leaving its purpose unclear. Since two of three parameters are meaningfully described and the omitted one has a default empty string, the compensation is strong but incomplete, warranting a 4.

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

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

The description has a specific verb ('Returns') and resource ('ordered behaviour motifs'), with a precise definition: sequences of (regime, signal_key, action, outcome_sign) steps that at least 10 DISTINCT agent cohorts exhibited and map to NO existing strategy type. This clearly distinguishes it from sibling tools like get_collective_insights or get_strategy_suggestions by emphasizing 'emerging' patterns not in the taxonomy.

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

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

The description gives clear when-to-use context via 'Workflow: INTELLIGENCE step -- see what the fleet is doing that no existing strategy type describes, before designing a new strategy.' It also warns it is 'descriptive only, never a recommendation,' which prevents misuse. However, it does not explicitly name alternatives or state when not to use it, so it stops short of a full 5.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by explaining the health factor meaning and return fields, which goes beyond what annotations provide. No contradictions.

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 with two sentences, front-loading the core purpose and critical output details. No extraneous words; every sentence adds value.

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

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

Given the tool's simplicity and presence of an output schema, the description adequately covers the purpose, output fields, and protocol constraints. It misses optional parameter explanations but is otherwise complete for a query tool.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions protocol (kamino/marginfi) but does not explain wallet_address, market, marginfi_account, or caller_id. This leaves significant gaps for a 5-parameter tool.

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 monitors liquidation risk for lending positions, returning health factor with thresholds (>1 safe, <1 liquidatable) along with collateral/debt values. It specifies supported protocols (kamino, marginfi), distinguishing it from siblings like get_lending_rates or set_liquidation_alert.

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

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

The description implies usage for checking liquidation risk but lacks explicit when-to-use or when-not-to-use guidance. It does not differentiate from other getters or state alternatives. Given the straightforward nature of a query tool, the implicit guidance is adequate but not exemplary.

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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds substantial context: it explains what constitutes a valid transaction (executed trades only), that counts are aggregate and no per-wallet data, and that the metric is informational. It also details the cluster parameter behavior. This goes beyond annotation hints.

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 verbose and includes extensive background (Andrew's decision, transaction definitions, caveats). While informative, it could be more concise. Each sentence adds value, but the length may reduce quick readability.

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

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

Given the complexity of the tool's logic and the presence of an output schema, the description covers the key aspects: purpose, condition, metric definitions, and constraints. It explains what is not counted and warns about the informal nature. Minor gaps in parameter descriptions prevent a 5.

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%, but the description only mentions 'cluster=devnet' in passing, leaving the 'caller_id' parameter completely unexplained. Neither parameter has explicit semantics, relying on default values. This is inadequate for a 2-parameter tool.

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 returns the ILO adoption status, including whether the gate is met based on active user count. It specifies the exact condition (1000 active users with 5 executed transactions in 7 days). It distinguishes this tool from siblings by focusing on a specific readiness metric.

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

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

The description implies usage for checking readiness before ILO proceeds, but it does not explicitly state when to use or not use this tool versus alternatives. It provides context about the decision rule but lacks direct guidance on selection among sibling tools.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds that it computes readings only, involves no wallet/fee/on-chain action, and that readings are None while history is warming up. This goes beyond annotations and clarifies 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 lengthy but well-structured with a clear opening, bullet-like listing of indicators, parameter explanations, and workflow context. Every sentence adds value; it is efficient for its complexity.

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 (multiple indicators, parameters, output schema exists), the description covers input semantics, behavior during warm-up, workflow integration, and disclaimers. No gaps remain for an informed selection and 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%, so the description fully compensates by explaining each parameter: asset is a token mint, timeframe with allowed values, indicators as a subset array, params as a JSON override, lookback capped at 500, include_series for per-bar data. It also describes the output indicator structure with examples.

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 computes the full standard technical-indicator set for one asset/timeframe, specifying it is read-only. It lists the indicators (sma, ema, etc.) and differentiates from sibling tools by labeling it as an INTELLIGENCE step and suggesting pairing with get_ml_signal, get_signals, etc.

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

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

The description provides explicit context: it's for raw indicator readings as part of a workflow, not financial advice, and readings are None during warm-up. It mentions pairing with detect_regime, get_ml_signal, get_signals, and refers to get_trading_workflow. However, it does not explicitly state when not to use or alternatives beyond these siblings.

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

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

The description states 'Read-only', which aligns with annotations (readOnlyHint=true). It adds minor context about the data scope (per-action, per-month) but does not disclose any additional behavioral traits beyond what annotations already provide. With annotations covering the safety profile, a 3 is reasonable.

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 at two short fragments, but the conciseness comes at the cost of missing essential information like parameter details. It is not well-structured for an agent to understand how to invoke the tool correctly.

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 an output schema existing, return values are covered externally. However, the description lacks parameter semantics, usage context, and any behavioral nuances beyond read-only. For a tool requiring a wallet address, the omission is significant.

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 fails to explain any of the three parameters (limit, caller_id, integrator_wallet_address). The phrase 'per-action + per-month' hints at aggregation but does not clarify parameter roles or defaults. 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 retrieves integrator earnings, specifying 'per-action + per-month' and 'onboarding API', which provides a specific verb-resource combination. However, it does not differentiate from sibling tools like get_integrator_stats, so a 4 is appropriate.

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, no conditions or prerequisites. The description simply states what it does without any contextual usage advice.

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?

Beyond annotations (readOnlyHint, idempotentHint), the description explicitly clarifies that all figures are fee-share USD, not PnL or performance-share, adding valuable behavioral context not inferable from annotations alone.

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

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

The description is extremely concise, using two clear sentences with no redundancy. The first sentence lists the data categories; the second clarifies the fee-share nature. Every sentence adds value.

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

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

While the output schema presumably covers return structure, the description omits critical context like the required integrator_wallet_address parameter, prerequisites, or a more detailed breakdown of the dashboard fields, making it incomplete for a tool with no parameter documentation.

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

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

With 0% schema description coverage, the description fails entirely to explain the two parameters ('caller_id' and 'integrator_wallet_address'), their meaning, or how to use them, leaving the agent without necessary context.

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 an integrator dashboard including status, share, onboarded count, and earnings breakdown, using a specific verb-resource combination. It distinguishes itself from the sibling tool 'get_integrator_earnings' which focuses only on earnings.

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

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

Usage context is implied (for integrators wanting a dashboard overview), but no explicit guidance is given on when to use this tool versus alternatives like 'get_integrator_earnings' 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?

The description adds significant behavioral context beyond the annotations, such as 'Never infers', the fail-closed reporting approach, and the specific meaning of UNKNOWN and CONFIRMED. This aligns with and enhances the readOnlyHint, idempotentHint, and destructiveHint 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 concise, consisting of two sentences that front-load the purpose and then provide essential behavioral details. Every sentence adds value without unnecessary words.

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

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

Given that an output schema exists, the description appropriately focuses on what the tool does and the semantics of the returned states rather than repeating return value details. The behavioral explanations make the tool's usage complete 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?

The input schema has 0% description coverage, and the description provides no additional meaning or guidance about the parameters (intent_id and caller_id). As a result, the agent must rely solely on the schema types and defaults, which is 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?

The description explicitly states 'Read the persisted lifecycle state of an execution intent (free read)' and lists all possible states, clearly defining the tool's purpose. It distinguishes itself from sibling tools like create_execution_intent by emphasizing its read-only nature and specific state semantics.

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

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

The description provides clear context on when to use the tool (for reading lifecycle state) and clarifies the meaning of ambiguous states (UNKNOWN vs CONFIRMED), but does not explicitly mention when not to use it or offer alternative tools.

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

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

Annotations already indicate safe read-only behavior. Description adds meaningful context: crypto-only, no equity, no return promises (rule 8), each entry includes backtest metrics and on-chain attestation hash. No contradiction with annotations.

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

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

Two concise sentences with front-loaded purpose. Every sentence adds value: purpose, scope, sort options, and data contents. No wasted words.

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

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

Given 4 optional parameters, output schema exists, and annotations cover safety, the description adequately addresses purpose, scope, sort behavior, and data integrity. Minor omission: could mention limit effect, but output schema may handle pagination.

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 description provides interpretation for the 'sort' parameter (enumerated options and default). Other parameters (limit, caller_id, strategy_type) are not explained, leaving some ambiguity.

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 identifies the tool as retrieving top published strategies ranked by a verified backtest metric, with specific crypto-only scope and equity exclusion. Distinguishes from related sibling tools like get_score_leaderboard and get_strategy_leaderboard.

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

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

Provides clear context for when to use (ranking crypto strategies) and when not (equity templates excluded). Lists sort options and default. Does not explicitly name alternatives but the scope differentiation is implied.

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

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

Annotations already disclose readOnly, openWorld, idempotent. Description adds specifics on output fields and protocols, enhancing behavioral clarity without contradiction.

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

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

Concise three sentences: purpose, output fields, workflow context. No fluff, front-loaded with core action.

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

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

Complete for a simple query tool. Annotations cover safety, output schema exists, description adds protocols and field details. No gaps.

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

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

Only optional caller_id parameter with default. Schema coverage is 0%, but description omits any parameter details. However, caller_id is trivial and not required, so minimal impact.

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 verb 'Compare' and resource 'supply/borrow rates across Kamino + Marginfi'. Lists output fields and differentiates from siblings like get_lst_yields and get_trading_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?

Identifies as YIELDS step for idle/low-conviction capital, pairs with get_lst_yields, and refers to get_trading_workflow. Provides clear context for when to use.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. Description adds that the tool compares APY and mentions descriptors, aligning with annotations. No contradiction.

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

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

Extremely concise with front-loaded purpose and workflow integration. No wasted words.

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

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

Adequately covers functionality and workflow for a read-only tool with output schema. Minor omission of parameter detail but overall sufficient.

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

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

Only parameter caller_id is not described in text, and schema description coverage is 0%. Parameter is optional with default, but description should at least mention its 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?

Clearly states the tool compares APY across LST providers (Marinade/Jito/Blaze) with descriptors like MEV-boost and validator-count, distinguishing it from sibling tools like get_lending_rates or liquid_stake.

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

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

Provides workflow context: positions this as a 'YIELDS step' contrasting staking vs lending, and guides to execute via liquid_stake. Lacks explicit exclusions but gives clear usage scenario.

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

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

Annotations already indicate read-only, idempotent, open-world, non-destructive. The description adds significant behavioral details: source aggregation, tiered pricing with specific costs, required authentication for paid tiers, billing outcome field, and the disclaimer 'Not financial advice.' No contradictions with annotations.

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

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

The description starts with a clear purpose, then explains parameters and workflow. It is well-structured but slightly verbose in billing details (e.g., 'metered at $0, quota'd per day') which could be condensed. Overall, every sentence contributes, but some redundancy exists.

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 (tiered pricing, paid vs free, workflow integration) and the presence of annotations and output schema, the description is complete. It covers usage context, parameter semantics, behavioral traits, and return value highlights (billing field). No major gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'assets' as optional tickers and 'detail_level' with values 'free', 'pro', 'platinum' including costs and personalization. It mentions 'payment_header' and 'wallet_address' for paid tiers but does not detail 'caller_id' or 'timeframe'. While valuable, some parameter meanings remain implicit.

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 returns a 'market briefing aggregated from free crypto data sources' with specific components (summary, top movers, sentiment, Fear & Greed). It distinguishes itself from sibling tools that are more narrowly focused (e.g., get_market_regime, get_signals) or financial data like equity_quote. The verb 'get' + resource 'market briefing' is specific and unique.

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

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

The description provides explicit workflow guidance: 'INTELLIGENCE step (usually first) -- macro/sentiment context that frames detect_regime + the allocation.' It also explains paid tiers require subscription or payment_header. However, it does not explicitly state when not to use it or list alternative tools for similar purposes, though the sibling set is large.

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