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

Discloses failure conditions (MarginModeNotIsolated, NoOpenPosition, margin floor), requires API credentials, and explicitly states 'moves REAL margin'. No annotations present, so description carries full burden and meets it.

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

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

Two sentences: first covers purpose and failure conditions, second clarifies amount format and requirements. Efficient and front-loaded with key information.

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

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

Covers purpose, failure modes, parameter format, and real impact. No output schema, so return value is not addressed. For a 3-parameter tool with no annotations, provides sufficient 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 100%, so baseline is 3. Description adds that 'amount' is a positive decimal string, which matches schema. No significant additional meaning beyond what schema provides.

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

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

Clearly states action (add/remove isolated margin), resource (margin on open position), and distinguishes from siblings like deposit_collateral. Includes failure conditions indicating scope.

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

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

Provides failure modes but does not explicitly state when to use this tool vs alternatives like deposit_collateral. Implies usage context 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?

Discloses atomic cancel-replace, margin check, and that it modifies a real order. Since no annotations are provided, the description carries full burden and covers key 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?

Four sentences, front-loaded with the main action, no unnecessary words. Efficiently communicates purpose and constraints.

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

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

Given no output schema, the description adequately explains the operation, prerequisites, and constraints. It could mention that the response likely includes the amended order, but completeness is sufficient.

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

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

Schema coverage is 100% with clear parameter descriptions. The description adds context about the margin check but does not significantly enhance understanding of individual parameters beyond the schema.

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

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

The description clearly states the tool amends a resting order's price and/or size in an atomic cancel-replace operation. It distinguishes itself from sibling tools like cancel_order and place_order by using specific verb+resource.

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?

States that liquidation orders cannot be amended and requires API credentials, providing some usage context. However, it could more explicitly compare to cancel+place sequence.

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

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

No annotations are provided, so the description must disclose behavioral traits. It reveals that the tool requires API credentials (authentication needs) and has a safety guard against accidental mass cancellation. This adds useful context beyond the schema, though it could mention side effects or return values.

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 (3 sentences) and front-loaded with the main action. Every sentence provides necessary information without redundancy. No fluff or extraneous details.

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

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

Given 3 parameters, no output schema, and no annotations, the description covers the core use cases, safety constraints, and authentication. It lacks details on return values or error handling, but for a cancellation tool, the provided information is fairly complete for an agent to understand correct invocation.

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

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

Schema coverage is 100%, with each parameter described in the input schema. The description adds value by explaining the interplay between parameters: 'order_id' vs 'cancel_all', and that 'market_id' is required for single order cancel but optional with 'cancel_all'. This clarifies conditional requirements beyond the 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 cancels a resting order, and distinguishes between single-order and mass cancellation with specific parameter requirements. It uses precise verbs ('cancel') and identifies the resource ('resting order'), making its purpose unambiguous and distinct from siblings like 'amend_order' or 'place_order'.

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

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

Explicit guidance is provided on when to use each mode: pass 'order_id' for single cancel, or 'cancel_all: true' for mass cancel. It warns that an empty call is rejected to prevent accidental mass cancellation. However, it does not explicitly state when not to use the tool (e.g., for modifying orders) or mention alternatives.

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

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

No annotations are provided, so the description carries full burden. It discloses: daily allowance cap (default 500 USDX, resets midnight UTC), optional amount vs. full claim, synthetic nature, and API credential requirement. However, it does not detail side effects like whether repeated calls within the day reduce allowance or how failures are handled.

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

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

Two sentences, no wasted words. Front-loaded with core purpose and immediate constraints. Highly efficient.

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

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

For a simple one-parameter tool with no output schema, the description covers all necessary aspects: what it does, constraints, parameter behavior, and prerequisites (API credentials). No gaps remain.

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

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

Schema coverage is 100% with one parameter. Description adds semantic value: 'positive decimal string' type constraint and 'omit to claim full remaining allowance' usage rule. This fully explains the parameter's purpose and behavior.

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

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

The description clearly states the action 'claim synthetic USDX credit from the testnet faucet' and specifies the resource (USDX, testnet) and constraints (daily allowance, default 500 USDX, resets midnight UTC). It distinguishes from sibling 'claim_faucet' by specifying the synthetic USDX 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?

The description indicates when to use (to get testnet USDX) and explains behavior with optional amount parameter. It does not explicitly state when not to use or name alternatives, but the context is straightforward for a faucet 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?

Discloses key behavioral traits: fixed amount, per-wallet cooldown, cumulative cap, testnet context, and authentication requirement. Without annotations, this is adequate, though does not detail cooldown duration or error responses.

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, 72 words, front-loaded with core purpose, no superfluous text. 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?

For a simple tool with no parameters and no output schema, the description covers purpose, constraints, and differentiation from sibling. No critical gaps given the tool's complexity.

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

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

No parameters exist (0 params), baseline is 4. Description confirms no arguments needed, adding clarity beyond the empty schema.

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

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

Explicitly states the action (claim), the resource (fixed testnet faucet amount of synthetic USDX), and context (authenticated account, cooldown/cap). Clearly distinguishes from sibling claim_credit by noting the fixed amount server-side.

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?

Directly compares with claim_credit, specifying that the amount is fixed and no arguments needed, guiding the agent when to choose this tool. Also mentions requirement of API credentials.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It critically warns that the secret is returned only once, which is a key behavioral trait. Adding details about key limits or replacement would strengthen it further, but current detail is strong.

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

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

The description consists of three concise sentences, each serving a clear purpose: stating the action, highlighting a critical warning, and specifying authentication requirements. No unnecessary words or redundancies.

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 zero parameters and no output schema, the description covers the essential aspects: purpose, critical behavior (secret shown once), and authentication requirement. It could mention the HMAC type more explicitly or describe the key's usage, but overall 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?

The input schema has no parameters and 100% coverage, so the baseline is 3. The description adds value by explaining the behavior and authentication context, which compensates for the lack of parameters and justifies a higher 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 'Create a new HMAC API key for the authenticated wallet', which is a specific verb and resource. It distinguishes itself from sibling tools like 'delete_api_key' and 'list_api_keys' by focusing solely on creation.

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

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

The description mentions the prerequisite of a session token from 'login' but does not explicitly state when to use this tool versus alternatives like deleting or listing keys. However, the context of creation is clear, and siblings serve different purposes, providing implicit 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?

The description adds important behavioral details: idempotency (repeated calls return same address) and the effect of sending assets (credits the account). It also notes credential requirements. However, with no annotations, it doesn't disclose potential side effects like creation on first call or any rate limits, which would be useful.

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

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

The description is concise (three sentences) and front-loads the core purpose. Every sentence adds value - idempotency and credential requirements are relevant. It could be trimmed slightly, but it's 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?

For a simple single-parameter tool with no output schema, the description covers purpose, usage context, and idempotency. It lacks details about possible creation side effects or error conditions, but given simplicityholistically, it's adequately complete.

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

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

Schema coverage is 100%, so the schema already documents the chain parameter. The description adds a hint to use get_bridge_assets for supported chains, which is helpful. But it doesn't add significant meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool gets or creates a cross-chain deposit address, specifying the resource (deposit address) and the verb (get-or-create), and distinguishes it from siblings like list_bridge_deposit_addresses and get_deposit_target by scoping to the authenticated account and a specific chain.

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

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

It provides clear context on when to use (to obtain a deposit address for receiving assets) and explicitly mentions idempotency per (account, chain). However, it does not explicitly state when not to use it versus alternatives like get_deposit_target, 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?

With no annotations provided, the description carries the full burden and does so thoroughly: it discloses that the server cannot sign, the message must be signed externally, the message is opaque and must be echoed verbatim, the nonce is informational, the challenge is not single-use, and calling it changes no state. It also explains the 503 condition and auth requirement.

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

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

The description is dense but every sentence earns its place—it covers purpose, signing method, opaque message handling, nonce clarification, single-use myth, safety, error handling, and auth. It front-loads the core purpose and flows logically without repetition 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 there is no output schema, the description fully explains the return values (message, expires_at) and how to use them (sign externally, pass to register_bridge_wallet). It also covers error conditions and auth, making it complete for an agent to call 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 schema already fully describes the address parameter (100% coverage), setting a baseline of 3. The description adds value by explaining that you must control the key and that step 2 proves it, reinforcing the parameter's purpose beyond the schema's literal definition.

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 it is Step 1 of registering a withdrawal wallet, returns the exact message to sign and its expiry, and differentiates itself from the sibling register_bridge_wallet by naming it as the next step. This leaves no ambiguity about what the tool does.

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

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

It gives explicit usage guidance: call this before deciding to register (safe due to no state change), then pass the result to register_bridge_wallet. It also explains the 503 error means registration is off and retrying won't help, effectively telling when NOT to use it.

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

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

The description explicitly states the destructive nature: 'any caller using that key stops working'. It also mentions the authentication requirement via session token. With no annotations provided, the description adequately conveys the key behavioral traits, though it could mention permission requirements or reversibility.

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 with three sentences. The first sentence states the purpose, the second emphasizes destructiveness, and the third covers the required parameter and authentication. 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?

Given the tool's simplicity (2 parameters, no output schema, no annotations), the description covers purpose, destructive impact, required parameter, and authentication. It could mention potential errors or the response, but it is largely complete for effective use.

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

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

Schema coverage is 100% and schema descriptions for both parameters (key_id and confirm) are already detailed. The tool description repeats the requirement to pass confirm: true but adds no new semantic information beyond what is in the schema.

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

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

The description clearly states the verb 'Delete (revoke)' and the resource 'HMAC API key by its key id'. It distinguishes this tool from sibling tools like create_api_key and list_api_keys by specifying the action and resource.

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 (to revoke an API key) and includes a necessary requirement to pass confirm: true. It also mentions authentication via session token, which is essential for using the tool. However, it does not explicitly state when not to use it or mention alternatives.

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

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

The phrase 'This moves REAL collateral on the account' discloses a critical behavioral trait (irreversible action). However, with no annotations provided, the description could further clarify side effects, error conditions, or confirmation steps.

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

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

The description is two concise sentences, front-loaded with the action and followed by essential parameter guidance and a behavioral note. 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?

For a mutation tool with no output schema, the description covers the basic purpose and a key behavioral trait. However, it lacks information about return values, error handling, or post-action state, leaving the agent with incomplete context.

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

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

The input schema covers 100% of the parameter, and the description merely restates what the schema already says (amount is a positive decimal string). No additional semantic context is provided beyond the schema.

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

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

The description clearly states the action ('deposit USDX collateral') and the target ('authenticated account'). However, it does not distinguish from the sibling tool 'submit_deposit', which may cause confusion about the specific 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 mentions 'requires API credentials' but does not provide guidance on when to use this tool versus alternatives like 'submit_deposit' or 'claim_faucet'. No when-not-to-use or prerequisites are specified.

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

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

With no annotations provided, the description carries the full burden and does well: it explains the negative maker rate rebate semantics, the meaning of `volume_30d_estimated: true`, the forward-looking vs realized distinction, and the credential requirement. This is notable behavioral detail beyond the bare function name.

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 main purpose, and every clause adds distinct value: content, rebate explanation, scope caveat, estimation caveat, and credential requirement. No wasted words.

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

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

For a zero-parameter, no-output-schema, no-annotation read tool, the description fully covers what the tool returns, important interpretation caveats, and prerequisites. It gives the agent enough to select and invoke it correctly.

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

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

The tool has zero parameters and the input schema is empty, so the baseline is 4. The description adds meaningful context about what the returned fee schedule represents, even though there are no parameters to document.

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

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

The description opens with a specific verb and resource: 'Get the authenticated account's effective fee schedule.' It enumerates the exact contents (maker/taker rate, fee tier, rolling volume, discounts) and clarifies the forward-looking scope, distinguishing it from realized per-fill averages and per-market rates.

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

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

It gives clear context for when this tool is appropriate: it returns the effective, forward-looking schedule rate, not realized per-fill averages, and notes that per-market rates differ. It also states that API credentials are required. However, it does not explicitly name alternative 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?

No annotations are provided, so the description carries full burden. It discloses fail-closed behavior (502 authoritative_margin_unavailable), null semantics with companion error fields, the always-null leverage field, and the special case of funding_paid. This is rich behavioral detail beyond what annotations might 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 dense but every sentence adds value. The primary purpose is front-loaded, and edge cases are explained without redundancy. It is long but justified given the complexity of the return state and potential null fields.

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

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

The description fully explains the return shape ({ summary, positions }), per-position risk details, null/value semantics for derived fields, funding_paid behavior, and error conditions. Since there is no output schema, the description covers all necessary context for an agent to understand what the tool returns and how to interpret edge 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?

The tool has zero parameters, and the schema is empty, so there are no parameter semantics to explain. The baseline for 0 params is 4; the description adds no param info but doesn't need to.

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 the tool returns the account's full state (summary + positions) in one call. The verb 'Get' plus the resource 'authenticated account's full state' is specific and distinguishes it from sibling tools like get_account_summary and get_positions.

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 recommends this tool over pairing get_account_summary with get_positions, noting the coherent read ensures summary.open_positions_count matches positions length. It also advises retry behavior on 502, giving clear 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?

With no annotations provided, the description carries the full burden and does an excellent job. It discloses the fail-closed behavior with the specific 502 error code, exactly what withdrawable means, that it never goes negative, and importantly instructs not to misinterpret the error as an empty account—rich and specific behavioral context.

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

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

Every sentence carries unique information: what the tool returns, how it differs from get_balance, the withdrawable definition, error semantics, retry behavior, and the credential requirement. It is dense but not redundant; the length is justified by the behavioral richness.

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

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

For a zero-parameter, no-output-schema tool, this description is complete. It covers the purpose, return semantics, error conditions, proper handling, and authentication requirements. There are no undocumented input fields to worry about and the sibling context clarifies its niche relative to get_balance and other account tools.

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?

This tool has zero parameters, so the baseline is 4 per the rubric. The description adds meaning by explaining the output fields (equity, margin usage, PnL rollup, withdrawable), which helps beyond schema since no parameter details are needed.

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

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

The description opens with a specific verb and resource: "Get the authenticated account's portfolio summary (equity, margin usage, PnL rollup)" — this clearly states what the tool does. It also explicitly distinguishes itself from the sibling get_balance by calling itself "a richer view", making it easy to differentiate.

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 names get_balance as an alternative and positions this tool as the richer option, giving clear context for when to choose it. It also includes actionable guidance such as requiring API credentials and advising a retry after a delay on 502, though it stops short of a fully explicit when-not-to-use list.

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

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

Without annotations, the description carries the behavioral disclosure burden. It communicates that credentials are required and the operation is a read ('Get'), but it does not mention ordering, pagination behavior beyond the schema, or what events exactly appear. It is adequate but not rich.

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

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

The description is a single, front-loaded sentence that states the purpose and the critical auth requirement. There is no redundant detail or filler.

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

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

For a read-only, two-parameter tool with fully documented schema and no output schema, the description provides enough context: it names the resource, scope, and credential requirement. It could mention return format or ordering, but the phrase 'ADL events' makes the expected output reasonably clear.

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

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

Schema description coverage is 100%, so the description does not need to explain parameter formats. It adds minimal context by clarifying that the address refers to the account whose ADL events are fetched, but this is largely inferable from the tool name and 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 verb 'Get' and the specific resource 'auto-deleveraging (ADL) events', scoped to 'a given account'. This distinguishes it from the sibling tool get_market_adl_events, which is market-level ADL 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 supplies clear context: this is for account-level ADL history and requires API credentials. It does not explicitly name alternatives or exclusions, but the account-level scope implies when it should be used versus the market-level sibling.

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 far beyond the minimal: it explains nullable fields and companion error fields, cautions that leverage is currently always null, and clarifies that funding_paid is a real zero rather than unknown. With no annotations provided, the description carries the full behavioral disclosure burden and handles it exceptionally well.

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?

While the description is detailed, every sentence serves a purpose: scope, null semantics, format-specific caveats, and authentication. It is front-loaded with the core purpose and then elaborates only where ambiguity would otherwise cause incorrect agent behavior.

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

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

Given there is no output schema and no annotations, the description is remarkably complete. It covers the tool's inputs, output areas, edge-case semantics, authentication requirement, and even how to interpret signs on funding_paid. A no-parameter tool like this is fully usable based on the description alone.

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

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

The tool has zero parameters, so there is no parameter ambiguity. The description adds useful meaning about response-level field semantics, which exceeds the baseline for a zero-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 the tool returns an authenticated account snapshot including collateral balance, equity, and positions, which is specific and unambiguous. The exact scope also differentiates this from sibling tools like get_positions or get_account_summary, even without naming them explicitly.

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

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

It clearly communicates that this requires API credentials and is appropriate for getting a broad account snapshot rather than a focused detail like only positions. It does not explicitly mention when to prefer sibling tools, but its stated context is sufficiently 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It adds valuable context beyond the empty schema by stating it's a 'Public catalog — no credentials needed,' and enumerates the output fields. It could mention read-only semantics explicitly, but 'List' and catalog nature imply a safe read operation.

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

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

Two sentences, front-loaded with the main action, followed by justification and usage. Every word earns its place—no redundancy or filler.

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

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

Despite lacking an output schema, the description fully covers what the tool returns (chains, assets, decimals, minimums, confirmations, fees) and notes public access without credentials. It's complete for a catalog-like endpoint with no input parameters.

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

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

The tool has zero parameters, so the schema provides no information. The description adds no parameter semantics (unnecessary) but establishes the purpose of discovering chain values, which is parameter-adjacent. Per rubric, 0 params earns a baseline of 4, which is appropriate.

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

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

The description clearly states the tool lists bridgeable chains and per-chain asset details (depositable/withdrawable, decimals, min amounts, confirmations, fees). It uses a specific verb+resource and distinguishes itself by noting it's a public catalog and a discovery mechanism for chain values used by other bridge tools, setting it apart 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?

It explicitly says to 'Use it to discover valid `chain` values for the other bridge tools,' providing a clear when-to-use directive. While it doesn't enumerate alternatives, the reference to 'other bridge tools' implies its consultative role, which is sufficient for a discovery 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 are absent, so the description carries the full burden. It adds useful context beyond the schema: only deposits owned by the authenticated account are returned, and API credentials are required. However, it doesn't disclose behaviors like error handling, not-found responses, or the response format. This is a moderate level of disclosure, hence a 3.

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

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

The description is a single, front-loaded sentence that conveys the essential information without any fluff. Every clause adds value: the action, the resource, the ownership constraint, and the credential requirement. Perfectly concise.

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

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

For a simple fetch-by-id tool with one parameter and no output schema, the description adequately states the operation and the ownership scoping. It could have explicitly mentioned the return type, but 'Fetch' implies the deposit object. It lacks details on error cases but is otherwise complete for the simplicity of the tool, hence a 4.

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

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

The only parameter 'id' is already fully described in the schema as 'Deposit identifier.' The description adds no further semantic detail beyond reiterating that the tool fetches by id. With 100% schema coverage, the baseline is 3, and no additional information is provided.

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

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

The description clearly states the verb ('Fetch'), the resource ('a single cross-chain (bridge) deposit'), and the method ('by id'). It also distinguishes from sibling tools like list_bridge_deposits by emphasizing 'single' and adding an ownership constraint, making the scope 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 makes it clear when to use the tool—when you have a specific deposit id and need that deposit's details. It does not explicitly mention alternatives or when not to use it, but the scoping to 'single' and 'by id' provides a clear usage context. No exclusions are stated, so it earns a 4 rather than a 3.

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

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

No annotations provided, so description fully discloses behavior: explains the dead man's switch, return fields, and the REST-only exclusion. Also notes credential requirement.

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?

Compact, well-structured description that packs detailed semantics without waste.

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 zero-parameter getter with no output schema; describes return fields, edge case, and prerequisites.

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

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

No parameters exist; baseline 4 applies, and description adds no parameter info needed.

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

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

Clearly states it retrieves the account's COD status, explains what COD is, and the verb 'Get' differentiates from sibling 'set_cancel_on_disconnect'.

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 and a when-not caveat for REST-only clients, but does not explicitly reference the alternative setter 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?

With no annotations provided, the description carries the full burden. It mentions public access and timeframe options, but lacks details on rate limits, data range, pagination, or caching. This is insufficient for a tool with no annotation safety net.

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, zero waste. The first sentence states the core purpose, and the second adds critical context (public access, timeframe details). 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?

The tool has 3 simple parameters and no output schema. The description explains the core function and key parameter options, but omits response structure (e.g., array of candles) and ordering. Adequate for simplicity but missing some context.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context for the 'timeframe' parameter (e.g., default value of 1m), but adds nothing beyond schema for 'market_id' or 'limit'.

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 'Get OHLCV candles for one market,' specifying the verb and resource. It also clarifies it's public and lists timeframe options, making the purpose distinct from sibling tools like get_ticker or get_orderbook.

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

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

The description implies usage by stating 'Public — no credentials needed,' but provides no explicit when-to-use or alternatives. It doesn't differentiate from similar data tools such as get_stats_history or get_ticker.

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

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

No annotations are provided, so the description carries the full burden. It discloses the pagination behavior, the opaque nature of the cursor, and the requirement for API credentials. It does not explicitly state whether this is a safe read operation, but the verb 'get' implies read-only. The description adds value beyond the schema by explaining the pagination loop and the meaning of 'next_cursor'. Missing explicit mention of rate limits or potential errors, but acceptable given the simple read operation.

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

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

The description is concise, clear, and well-structured. It starts with the purpose, then explains the output format and pagination flow. Every sentence provides necessary information without redundancy. The structure is logical: what it returns, how to paginate, and a note on credentials. No fluff.

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

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

Given the tool's complexity (pagination) and the absence of output schema, the description is complete. It explains the return format ('items' and 'next_cursor'), the pagination algorithm, and the semantics of each parameter. It even warns about not modifying cursors. The description covers all necessary aspects for an agent 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?

Schema coverage is 100%, so parameters are well-documented. The description adds extra semantics: 'limit' sets the size of ONE page, not a total, and 'cursor' should be passed verbatim, never constructed. This goes beyond the schema's basic description, providing operational context that helps correct usage. The clear explanation of cursor usage is particularly valuable.

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 ('Get the authenticated account's closed positions') and specifies the content ('realized PnL per position'). It distinguishes itself from sibling tools like get_positions (likely open positions) by explicitly including 'closed'. The pagination details further clarify the tool's purpose.

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

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

The description provides explicit usage guidance on pagination: how to use the cursor, when to stop, and the meaning of 'limit' as per-page not total. It does not explicitly mention when to prefer this over alternatives, but the context ('closed positions') makes the use case clear. Slight deduction for not contrasting with other history-oriented tools like get_fills or get_order_history.

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

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

No annotations provided, so description carries full burden. It describes the tool as a read operation on a live, public demo account. It does not disclose any side effects, rate limits, or data freshness, but for a simple read-only tool, the transparency is adequate.

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

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

Two sentences, front-loaded with purpose. No wasted words. Every sentence earns its place.

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

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

Given no parameters and no output schema, the description adequately explains what the tool returns (balance, equity, positions) and the context (no credentials, public demo). It is complete for its simplicity.

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

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

Tool has no parameters, and schema coverage is 100%. According to guidelines, 0 parameters yields baseline 4. The description adds value by explaining the output but is not required to parameter semantics.

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 it gets a live, public demo account snapshot with balance, equity, and positions. It distinguishes from sibling tools like get_balance and get_demo_positions by specifying the full snapshot.

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 'No credentials needed' and 'useful to show the account flow before API keys are wired up', providing clear context for when to use this tool. Does not explicitly mention when not to use, but the guidance is sufficient.

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

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

Without annotations, the description carries the full burden. It effectively discloses the authentication requirement (no credentials) and that it returns open orders from the demo account. However, it omits other behavioral traits such as real-time nature, response format, or rate limits, though the tool is simple and read-only.

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

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

Two concise sentences, no wasted words. The purpose is front-loaded in the first sentence, making it easy to parse.

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

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

Given no output schema, no annotations, and no parameters, the description covers the essential aspects: what it does, relative to whom (demo account), and authentication requirement. It is nearly complete for the tool's simplicity, but could mention the read-only nature explicitly.

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

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

The tool has no parameters, and the input schema is empty with 100% coverage. The description adds meaning by specifying the resource and state, which is adequate given the absence 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 states the verb (Get), resource (public demo account's open orders), and scope (open orders). It distinguishes from the sibling tool 'get_open_orders' by specifying 'public demo account', 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?

The description explicitly notes that no credentials are needed, which implies it is used for unauthenticated access. However, it does not directly contrast with the sibling tool 'get_open_orders' or state when not to use it, but provides sufficient context for typical usage.

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

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

No annotations provided. Description indicates it's a read operation on a public endpoint, but doesn't detail any behavioral aspects like rate limits or data freshness. Acceptable for a simple read-only tool.

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

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

Two short sentences, front-loaded with purpose and key attribute (no credentials). Every word earns its place.

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

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

For a parameterless read-only tool with no output schema, the description sufficiently covers the purpose and access requirements. No critical 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?

No parameters in schema, so description doesn't need to add parameter info. Baseline 4 applies.

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

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

Clearly states the action 'Get' and the resource 'public demo account's open positions'. Distinguishes from sibling 'get_positions' by specifying demo account and no credentials needed.

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 says 'No credentials needed', implying it's for quick access without authentication. Implicitly contrasts with the sibling 'get_positions' which likely requires authentication.

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

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

With no annotations provided, the description carries the burden of behavioral transparency. It discloses that the tool is superseded, legacy, and unbuilt server-side, which is critical. However, it does not describe what happens when the tool is called (e.g., likely error), nor any other behavioral details such as response format or potential failure modes.

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, front-loaded with the primary purpose, and includes a clear directive to use alternatives. Every sentence adds value, with no extraneous information.

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

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

For a simple tool with one optional parameter and no output schema, the description is fairly complete for guiding selection, but it falls short in explaining the consequences of invoking an unbuilt tool. It would be more complete if it stated expected behavior (e.g., 'calling this returns an error') or explicitly recommended against use, given it's unbuilt.

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

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

The schema already covers the single optional parameter 'asset' with a clear description and example, so the description adds little beyond noting the purpose. Since schema coverage is 100%, a baseline of 3 is appropriate, and the description does not need to elaborate further.

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

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

The description clearly states the tool returns the on-chain deposit target (address/memo) to fund the account, with a specific verb ('get') and resource ('deposit target'). It distinguishes itself from the sibling bridge deposit-address tools by explicitly noting they are preferred and that this is a legacy single-target lookup.

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 instructs users to prefer the bridge deposit-address tools (`create_bridge_deposit_address` / `list_bridge_deposit_addresses`) over this tool, and clarifies this is a legacy tool. It does not, however, mention when this tool should still be used, if at all, since it remains unbuilt.

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

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

With no annotations, the description fully discloses key behaviors: cadence, window, ordering (oldest first), return shape, opaque cursor semantics, per-page limit meaning, and credential requirement. This goes well beyond typical descriptions.

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 five sentences with each sentence serving a distinct purpose: purpose, alternative, return shape, pagination, and limit clarification. It is slightly verbose but well-structured and front-loaded.

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

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

Despite having no output schema and only two optional parameters, the description covers purpose, alternatives, return format, pagination mechanics, limit semantics, and auth requirements. This is complete for a paginated read 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 already covers both parameters with detailed descriptions (100% coverage), but the description adds operational nuance: limit is per page, not total, and cursor must be passed back verbatim with clear stopping condition. This complements the schema effectively.

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

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

The description clearly states the tool fetches the authenticated account's equity time-series with specific cadence (5s) and window (~1h). It distinguishes itself from get_portfolio_history by explicitly naming the alternative for longer windows or additional series, making the 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?

Explicit guidance is provided: use this for short-window equity data, and use get_portfolio_history for longer windows or PnL/volume. The pagination instructions (keep calling with cursor until next_cursor is null) give a concrete usage pattern.

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?

Notes that API credentials are required and explains the cursor-based pagination mechanism, adding behavioral detail beyond the basic read-only nature. No annotations were provided, so the description carries this burden effectively.

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 and well-structured, with no redundant wording. Each sentence serves a purpose, covering purpose, pagination, and parameter semantics efficiently.

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

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

Since there is no output schema, the description explains the return shape ({ items, next_cursor }) and the meaning of each field, making the tool's behavior fully understood.

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 to both parameters: clarifies limit is per-page (not total) and explains cursor usage (opaque token, pass back verbatim). This goes beyond the 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?

Clearly states the tool lists the authenticated account's fills (executed trades) in newest-first order, distinguishing it from related tools like get_trades or get_order_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?

Provides explicit pagination instructions (continue with cursor until null) and clarifies the per-page limit behavior, though it does not explicitly contrast when to use this over 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It adds useful context ('Public — no credentials needed') and scope, but does not describe the returned record structure, ordering, pagination, or any rate-limit behavior.

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

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

The description is two short sentences, front-loaded with the core action, and contains no filler. The public-access note is relevant and compact.

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 public read endpoint with two well-documented parameters, the description is largely sufficient for selection and invocation. The lack of an output schema means a bit more detail about the returned history would improve completeness, but this is not a major gap.

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

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

The input schema already provides full descriptions for both parameters, including the market_id example and limit's max/default. The description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get'), identifies the resource ('funding-rate history'), and scopes it to 'one perpetual market', making the tool's purpose clear. This also distinguishes it from sibling tools like get_funding_payments and get_funding_samples.

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

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

The description implies when to use the tool—when you need funding-rate history for a single market—and notes that it is public. However, it does not explicitly state when to prefer this over related tools such as get_funding_samples or get_funding_payments.

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

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

With no annotations, the description bears full burden. It discloses ordering (newest first), optional filtering, and authentication requirement. However, it does not mention rate limits, default behavior, or error states. The transparency is adequate but not comprehensive.

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

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

Two concise sentences, front-loaded with the action and result. Every word adds value: 'newest first' and 'optionally filtered' are essential. No redundancy or fluff.

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

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

For a simple read-only tool with no output schema, the description covers the key aspects: what it returns, ordering, filter option, and auth. Missing details like default limit or pagination are minor given the schema already specifies the limit parameter.

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

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

Schema coverage is 100%, so baseline is 3. The description adds the critical ordering context ('newest first') not present in the schema, which helps the agent understand the result format. It also confirms optional filtering, adding value beyond the schema.

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

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

The description clearly states the tool retrieves the authenticated account's funding-payment history with newest-first ordering and optional market filtering. While it is specific to funding payments, it does not explicitly differentiate from siblings like get_funding_history or get_funding_samples.

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

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

The description mentions the requirement for API credentials, but provides no guidance on when to use this tool versus related tools (e.g., get_funding_history, get_funding_samples) or when not to use it. No alternatives or exclusions are given.

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

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

With no annotations, the description correctly notes the tool is public (safe read) and specifies cadence and limit. However, it does not disclose error handling, side effects, or other behavioral details, leaving some gaps.

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

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

The description is extremely concise with two sentences, front-loading key information. Every sentence adds value with no 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?

While the description is clear and includes sibling comparison, it omits the return value structure or formatting. For a data retrieval tool with no output schema, this gap reduces 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 coverage is 100%, and the description does not add new meaning to the parameters beyond what the schema provides. Baseline score of 3 is appropriate as the schema already handles 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 retrieves dense per-tick funding samples for one perpetual market, with cadence and point limit specified. It explicitly distinguishes from sibling `get_funding_history`, 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?

The description provides a specific alternative (`get_funding_history`) and notes the tool is public with no credentials needed. This gives clear context for when to use it versus the sibling, though it does not cover all exclusions.

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

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

No annotations are provided, so the description must carry the full burden. It explains that ADL events involve force-closing positions to cover shortfalls, giving some behavioral context. However, it does not disclose read-only nature, rate limits, pagination behavior, or data freshness, leaving important behavioral traits unaddressed.

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. The first sentence is front-loaded with the core purpose and an explanatory clause, and the second adds a necessary prerequisite. Every word earns its place with no 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 simplicity (2 parameters, no output schema), the description covers the basic functionality and prerequisite. However, it lacks details about the return format or structure of the events, which would help an agent understand the output. Without an output schema, the description should compensate more.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the domain context (ADL settlement history) but does not add specific parameter details beyond what the schema already provides for 'market_id' and 'limit'.

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 'Get' and the resource 'auto-deleveraging (ADL) settlement history for one market', with an explanatory clause about what ADL events are. However, it does not differentiate from the sibling tool 'get_adl_history', which may have a different scope, leaving some ambiguity about when to choose this specific tool.

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

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

The description mentions a prerequisite ('Requires API credentials') and explains the tool's purpose, but it provides no guidance on when to use this tool versus alternatives, nor does it specify any exclusions or best practices. The usage context is implied by the resource description.

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

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

No annotations provided, so description carries burden. It discloses it's public and reads from engine's market registry. Beyond that, no details on rate limits, caching, or error behavior, which is acceptable for a simple query.

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

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

Two concise sentences with front-loaded purpose and immediate authentication context. 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?

Given single parameter, no output schema, and no annotations, description adequately explains purpose and public nature. Could briefly mention error handling for invalid market_id, but not essential.

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 covers market_id with example format. Description adds no extra meaning beyond the schema. Since schema coverage is high (100%), baseline 3 is appropriate.

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

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

Description clearly states verb 'get', resource 'one market's risk parameters', and specifies contents (margin requirements, maximum leverage). It distinguishes from sibling get tools by focusing on risk parameters.

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?

States the tool is public and requires no credentials, but does not explicitly specify when to use vs alternatives or when not to use it. Implicitly clear due to specificity.

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

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

No annotations are provided, so the description bears full responsibility. It states the tool is public and requires no credentials, which is key behavioral info. It does not disclose potential errors or rate limits, but for a simple read operation, these may not be critical. The description adds transparency beyond what annotations would 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?

A single sentence that is front-loaded with the action and resource, no redundant words, and every part is 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?

For a simple status-checking tool with one parameter and no output schema, the description covers purpose and authentication. It lacks detail on return format or errors, but completeness is acceptable given the low 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 100% (the only parameter market_id has a description with an example). The description text does not add additional meaning beyond the schema, so it meets the baseline of 3.

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

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

The description clearly states the verb 'Get', the resource 'market's trading status and halt info', and elaborates on what that includes (open, halted, auction). It distinguishes itself from siblings like get_ticker or get_mark_price by focusing on trading status and halt info.

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

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

The description mentions 'Public — no credentials needed', which implies usage without authentication. However, it does not explicitly state when to use this tool over siblings or provide any exclusions or alternatives. The guidance is implicit but not directive.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It mentions the tool is public and requires no credentials, which is useful. However, it does not disclose other traits like idempotency or rate limits, which for a simple read are acceptable. Score 3 as it adds some value but not comprehensive.

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

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

The description is a single sentence that immediately conveys the action and scope. No extraneous words. Perfectly front-loaded and concise.

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

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

For a simple read-only tool with one parameter and no output schema, the description is fully adequate. It specifies the operation, scope, and authentication requirement, leaving no ambiguity.

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

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

Schema coverage is 100% with one parameter described. The description adds an example value 'BTC-USDX-PERP', which provides concrete context beyond the schema's generic description. This aids the agent in understanding the expected 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 verb 'Get', the resource 'current mark price', and the scope 'for one market'. It is specific and distinguishes from siblings like get_ticker by explicitly mentioning 'mark price'.

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 that it is public and requires no credentials, but provides no guidance on when to use this tool versus alternatives such as get_ticker or get_orderbook. No when-not-to-use or explicit alternatives are mentioned.

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

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

No annotations provided, so description carries full burden. It mentions authentication but not return format, pagination, or limits. Minimal but adequate for a read-only tool with no parameters.

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

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

Two short sentences, no redundancy, every word adds value. Efficient and direct.

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

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

Given no output schema or annotations, the description covers purpose and precondition. Could specify that it returns a list of orders, but adequate for a simple fieldless 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?

No parameters to describe, schema coverage is 100%. The description adds value by mentioning the authentication requirement, which is not a parameter but a precondition.

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 retrieves resting (open) orders for the authenticated account, with a specific verb and resource. It is distinct from sibling tools like cancel_order or get_balance.

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

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

Specifies the authentication requirement, which is key context. No explicit when-to-use guidance, but the straightforward purpose makes it clear this is for viewing open orders.

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

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

No annotations exist; description discloses required API credentials, return fields, and that market_id is optional despite the spec. This is sufficient transparency for a read-only lookup tool.

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

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

Three sentences cover purpose, parameter nuance, and authentication requirement with no wasted words. Critical information is front-loaded.

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

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

For a simple two-parameter tool with no output schema, the description includes return fields, parameter behavior nuance, and authentication requirement, making it fully actionable.

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

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

Schema already documents both parameters with 100% coverage. The description adds nuance about market_id's routing purpose and current gateway behavior, providing context beyond the schema.

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

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

The description clearly states the verb ('Get') and resource ('a single order'), specifies what fields are returned (status, fills, remaining size), and distinguishes from sibling tools like get_open_orders and get_order_history which handle multiple orders.

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 guidance on when to include market_id and notes the gateway behavior. Does not explicitly list alternative tools for different contexts, but the sibling tool list itself helps agents select appropriately.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is public and requires no credentials, which is valuable. However, it does not explain behavior on invalid market_id, rate limits, or data freshness guarantees. The description is sufficient but leaves gaps.

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

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

The description is a single efficient sentence plus a short clarification. It is front-loaded with the core purpose (getting the order book) and immediately adds the public context. No unnecessary words or repetition.

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

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

The tool has one simple parameter and no output schema. The description explains what the tool returns (bids/asks with price and size) and that it operates on a single market. This is sufficient for a straightforward read-only tool with no complex side effects.

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

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

The schema covers 100% of the parameters (only market_id) and provides a description and example. The description does not add extra semantic detail beyond the schema. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states 'Get the current order book (bids/asks with price + size) for one market.' The verb 'get' specifies the action, and the resource and scope are explicitly defined. It distinguishes itself from siblings like get_ticker (which provides different market data) and get_open_orders (which returns user-specific orders). The public 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 mentions 'Public — no credentials needed,' implying it can be called without authentication, but it does not provide explicit guidance on when to use this tool versus alternatives like get_ticker or list_markets. No exclusions or prerequisites are stated, making it 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?

With no annotations provided, the description carries the full burden and delivers: return shape ({ items, next_cursor }), pagination semantics (opaque token, null terminal, verbatim pass-back), limit semantics (per-page not total), auth requirement ('Requires API credentials'), and ordering. This is rich behavioral disclosure well beyond what structured fields 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?

Five sentences, front-loaded with the core purpose, then efficiently covering return format, pagination, limit semantics, and auth. Every sentence earns its place with no fluff or verbatim schema repetition.

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

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

For a paginated list tool with no output schema and no annotations, the description is fully complete: it covers purpose, status filter, ordering, return shape, pagination loop, limit semantics, and credentials requirement. An agent has everything needed to invoke and iterate correctly without guessing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by tying both parameters into a coherent pagination loop and emphasizing the common misunderstanding that 'limit sets the size of ONE page, not a total.' The cursor mechanics are largely redundant with the schema, but the workflow integration and limit clarification justify 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 uses a specific verb+resource pair ('Get the authenticated account's terminal-status order history') and enumerates the exact statuses included (filled/cancelled/rejected/expired) plus ordering (newest first). The 'terminal-status' qualifier clearly distinguishes this from siblings like get_open_orders and get_order.

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

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

The description provides clear context on when to use the tool — for terminal-status orders of the authenticated account — which implicitly separates it from get_open_orders (non-terminal) and get_demo_orders (demo account). It also explains the pagination workflow ('keep calling with cursor until next_cursor is null'). However, it does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations, description fully discloses behavior: heavy read costing 5x budget, effect on `remaining` in rate-limit status, auth requirement, deposit-neutral PnL, monotonic volume, and per-window cadence/capacity. No contradictions with annotations (none provided).

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?

Dense but efficient; front-loads purpose, then precise details without fluff. Every sentence contributes essential info such as capacities, comparisons, and cost implications.

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

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

Despite no output schema, the description sufficiently describes return content, ordering, and key properties. Covers authentication, rate-limit impact, and window-specific constraints, making it complete for an agent to use correctly.

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

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

Schema covers both parameters but description adds deep meaning: explains how `window` selects cadence and capacity, how `limit` clamps to capacity, and default behavior. This exceeds schema basics and clarifies interplay.

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

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

Description clearly states the verb 'Get' with specific resource 'portfolio time-series' and enumerates content (equity, PnL, volume) and window behavior. Explicitly differentiates from sibling `get_equity_history`, 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?

Provides explicit when-to-use guidance by contrasting with `get_equity_history` and noting both derive from same source. Also warns about heavy rate-limit cost and advises polling sparingly, giving clear operational 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?

With no annotations provided, the description carries the full burden of behavioral disclosure and does so excellently. It explains null semantics for mirrored fields, companion `_error` fields, the always-null `leverage`, and the funding_paid sign convention, which are all critical non-obvious behaviors.

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?

Every sentence earns its place: it front-loads the purpose, then systematically explains potentially confusing return-field semantics, and finishes with the auth requirement. There is no filler or redundancy.

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

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

Given that there is no output schema and no annotations, the description is remarkably complete for a tool of this complexity. It preemptively answers likely questions about nulls, unknown values, mirroring failures, and funding sign, making the tool safe to invoke correctly.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter documentation burden. The description still adds useful context by mentioning that API credentials are required, which is appropriate for the 0-parameter baseline.

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

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

The description uses a specific verb and resource: 'Get the authenticated account's open positions.' The word 'open' distinguishes it from related tools like get_closed_positions and get_demo_positions, and it clearly scopes the operation to the authenticated account.

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

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

The description clearly frames when to use it: for the authenticated account's open positions, and it notes the API credential requirement. It does not explicitly name alternatives or exclusions such as demo or closed positions, but the context is clear enough.

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

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

The description notes that API credentials are required, disclosing an important behavioral requirement. It also hints at the return value ('remaining request budget') despite the lack of an output schema.

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

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

The description is extremely concise at two sentences and 17 words, containing only essential information without any waste.

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 no parameters, no output schema, and a simple purpose, the description fully covers what the tool does, why to use it, and what is required (authentication).

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 no parameters and 100% schema coverage, the description cannot add parameter-level detail beyond what the schema already conveys. The description does not introduce any parameter information.

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

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

The description uses a specific verb ('Get') and resource ('rate-limit status'), clearly identifying the tool's function. It distinguishes itself from sibling tools, none of which provide rate-limit 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?

The description explicitly states that the tool is useful for pacing an agent, providing clear usage context. While it doesn't mention when not to use it or alternatives, the simplicity of the tool makes exclusions unnecessary.

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

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

Discloses key behavioral trait: no credentials needed (public). Without annotations, the description carries the burden; it adds value by specifying the aggregate nature components, though lacks details on response format.

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

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

Two sentences, no redundancy, front-loaded with purpose. Every word earns its place.

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

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

Given no parameters and no output schema, description covers scope, components, use case, and auth. Lacks response structure but sufficient for a simple health check.

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

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

No parameters, so schema coverage is 100%. Description adds no param info, but baseline 4 applies per rules for zero-parameter tools.

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 provides 'aggregate service health' of specific components (indexer/engine/oracle/bots), distinguishing it from sibling tools like get_health that may focus on individual systems.

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

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

Mentions it's 'as used by status pages' and 'Public — no credentials needed', implying a public health check. Does not explicitly contrast with siblings or provide when-not-to-use guidance.

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

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

No annotations provided, but description declares it's public and no credentials needed, which are key behavioral traits. The read-only nature is implicit from 'Get'. Adds value beyond the name.

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 efficient sentences with no waste. Front-loads the main action and then adds the public access trait.

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

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

Given zero parameters and no output schema, the description fully explains what data is returned (volume, trades, throughput, rolling unique-trader counts) and access requirements. Complete for this simple tool.

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

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

No parameters exist, so baseline 4 applies. Description does not need to add param info.

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 'Get aggregate venue statistics' and lists specific fields (volume, trades, throughput) plus rolling unique-trader counts. Differentiates from siblings like get_stats_history and get_ticker by focus on current aggregate stats.

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 'Public — no credentials needed', indicating no authentication required. Though it doesn't list when-not or alternatives, the context is clear for a simple read operation.

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

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

The description discloses the ring buffer nature (implying limited history) and the maximum number of points (3600). It also clarifies that no credentials are needed. Given no annotations, this is good transparency, though it could mention data freshness or rate limits.

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

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

The description is a single sentence that front-loads the main purpose and follows with key details. Every word adds value, making it highly concise and efficient.

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

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

While the description explains the ring buffer and point limit, it does not describe the output format (e.g., timestamps and throughput values). Given no output schema, this omission leaves the agent without full understanding of the return structure.

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

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

The tool has zero parameters and schema coverage is 100%. The description correctly indicates that no credentials are needed, which is the only relevant contextual info. Baseline score of 4 applies per guidelines.

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 venue's per-second throughput history, specifies it's a ring buffer with up to 3600 points, and notes it is public. This effectively distinguishes it from sibling tools like get_stats or get_service_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?

The description indicates the tool is public and requires no credentials, which provides some usage context. However, it does not explicitly state when to use this tool versus alternatives (e.g., get_stats), nor does it provide exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is public and returns specific data fields, but lacks details on rate limits, data freshness, or any side effects. Basic transparency is present but not comprehensive.

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

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

The description is two concise sentences: the first states the tool's purpose, the second adds public nature and an example. Every sentence provides essential information with no redundancy or 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's simplicity (one parameter, no output schema), the description covers the main aspects: purpose, public access, and example. It lacks explicit details about return format or data freshness, but the mention of 'last price, bid/ask, 24h stats' gives sufficient context 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?

The single parameter 'market_id' is fully described in the schema with an example. Schema description coverage is 100%, and the tool description reinforces the example. The description adds value by providing a concrete example format beyond the schema's generic description.

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

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

The description clearly states the tool retrieves the ticker (last price, bid/ask, 24h stats) for a specific market. It includes an example market ID, distinguishes the tool from siblings (e.g., get_orderbook, list_markets), and notes the public 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?

The description explicitly says 'Public — no credentials needed,' providing clear guidance on when to use it. It doesn't explicitly state when not to use it or list alternatives, but the context of sibling tools and the tool's specific purpose imply appropriate usage scenarios.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool is public, requires no credentials, and returns ticker data for all markets in one call. This adequately informs the agent of the read-only, non-destructive 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?

A single, well-structured sentence that front-loads the key purpose and usage details. Every word is meaningful and efficient.

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

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

For a simple, parameterless tool, the description is complete. It explains what data is returned (ticker stats for all markets) and that it requires no authentication. No output schema is provided, but the description sufficiently covers the expected output.

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

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

The input schema has zero parameters and 100% coverage, so the baseline is 4. The description adds value by clarifying the scope (all markets) and the public access, though no parameter-level detail is needed.

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

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

The description clearly states the verb 'Get' and the resource 'tickers for ALL markets', specifying the data included (last price, bid/ask, 24h stats). This is distinct from the sibling 'get_ticker' which presumably retrieves a single ticker.

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 'Public — no credentials needed', providing clear context for when to use the tool. While it does not specify when not to use it, the context effectively implies it is for broad market data without authentication requirements.

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

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

With no annotations, the description carries the full disclosure burden and does it well: it exposes that the endpoint is public, no credentials needed, it returns paginated results, the cursor is opaque and must not be constructed, and the limit is per-page. This goes far beyond the bare minimum and gives the agent a solid mental model of runtime behavior.

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

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

The description is about four sentences, front-loaded with the core purpose, followed by output shape, pagination mechanics, and a public-access note. Every sentence contributes useful information with zero fluff; the structure logically progresses from what to how.

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 no output schema, no annotations, and a moderately complex pagination contract. The description fully explains the return structure, cursor lifecycle, and public context, which is sufficient for the agent to invoke and interpret results without surprises. Nothing critical is left dangling.

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

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

Schema coverage is 100%, so the baseline is 3. The description still adds value by emphasizing the cursor lifecycle (pass 'previous next_cursor' verbatim until next_cursor is null) and clarifying that limit controls one page, not the total history, which the schema does not explicitly contrast. This subtle extra semantic justifies 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 starts with a specific, unambiguous verb-resource-scope statement: 'Get recent public trades (prints) for one market, newest first.' It clearly identifies what the tool does, including ordering and scope, and distinguishes it from sibling market-data tools like get_ticker or get_orderbook.

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 guidance on pagination usage: how to walk the full history with next_cursor, when to stop, and that limit controls page size not total results. It also states the public access requirement ('no credentials needed'). It does not explicitly name alternatives or state when not to use it, but the usage context is well established.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds the requirement for authentication and implies a read-only operation via 'List', but does not disclose return format, pagination details, or side-effect-free confirmation. Minimal additional behavioral context is supplied.

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

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

The description is a single, front-loaded sentence with no redundancy. It conveys the essential purpose and a key requirement without excess, making it highly efficient.

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

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

The tool is simple with one optional parameter and no output schema. The description covers the purpose and authentication requirement, which is adequate for a basic read operation. It could mention whether results are chronological or paginated, but the schema already caps the limit, so the level of detail is sufficient.

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

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

Schema coverage is 100% for the single parameter 'limit', which is already described with a maximum cap. The description adds no additional meaning or usage nuance beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the action ('List') and the resource ('the authenticated account's withdrawal history'), distinguishing it from sibling tools like get_trades and list_deposits. The scope is explicit, ensuring no ambiguity about which data is retrieved.

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

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

The description provides a prerequisite (API credentials) but lacks guidance on when to use this tool versus alternatives. It does not mention exclusions or recommend it over similar tools for specific scenarios, making usage context only partially 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?

With no annotations provided, the description carries the full burden and does well: it discloses the 60-second single-use nature, the endpoint compatibility, the requirement of API credentials, and that the response includes ws_endpoint to avoid host guessing. It does not cover edge cases like timeout behavior or error conditions, but it provides strong behavioral context for a no-parameter token-minting operation.

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

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

The description is three sentences with no filler: it front-loads the core purpose, then explains endpoint/response details, and closes with the credential requirement. Every sentence earns its place.

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

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

For a tool with no input schema and no output schema, the description is remarkably complete. It explains why the tool exists, what it returns (including the ws_endpoint field), what credentials are needed, and how it relates to the endpoint version. The agent has enough information to invoke it correctly without additional context.

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

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

There are zero parameters, so the schema has nothing to document; the baseline for zero-parameter tools is 4. The description adds relevant context about authentication and the response payload, which helps the agent understand what the call produces even though no inputs are required.

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

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

The description clearly states the tool mints a short-lived, single-use token for an authenticated per-account WebSocket stream, with the specific use case of order/fill/position updates. It differentiates from siblings like get_ws_token_legacy by noting it uses the current /ws/token endpoint, and from market-data tools by scoping to authenticated account streams.

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

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

The description provides clear context: use this tool when you need a WebSocket token for per-account real-time updates, and it requires API credentials. It implicitly contrasts with the legacy sibling via 'current /ws/token endpoint,' but it does not explicitly state exclusions or name alternatives beyond that implication.

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

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

With no annotations, the description carries the disclosure burden. It covers token lifetime (60s), single-use nature, the endpoint, and the ws_endpoint in the response, plus credential requirement. It does not mention side effects like token invalidation or rate limits, but these are implied and minimal for a token mint.

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

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

Two sentences, each dense with relevant information: the first defines the action and endpoint; the second gives usage guidance and response detail. No filler or redundancy.

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

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

For a simple, parameterless tool with no output schema, the description is complete: it explains the token's purpose, lifetime, usage guidance, the ws_endpoint in the response, and prerequisites. Agents have enough to invoke correctly and interpret results.

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

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

There are zero parameters in the schema, so baseline is 4. The description adds no parameter details (none exist), but it does clarify the HTTP endpoint and token characteristics, which is sufficient given the parameterless interface.

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 mints a short-lived, single-use token for the legacy /stream endpoint via POST /ws-tokens, immediately distinguishing it from the sibling get_ws_token tool.

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 instructs to prefer get_ws_token for new code and only use this for legacy /stream compatibility, providing clear alternative and when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses authentication needs and the returned fields but omits details like read-only nature, pagination, or rate limits. Adequate but not comprehensive.

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

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

The description is a single, front-loaded sentence that conveys all essential information without any wasted words. It is optimally concise and 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?

For a simple parameterless list tool, the description covers the core purpose, output fields, and auth requirement. It could mention pagination or limits, but overall it is sufficient for an agent to understand 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?

With no parameters, schema coverage is trivially 100%. The description adds value by specifying what the output includes (address, label, expiry), which helps the agent understand the result. Baseline score of 4 for zero-parameter tools is appropriate.

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

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

The description explicitly states 'List the delegated agent keys' with a specific verb and resource. It details the fields returned (address, label, expiry) and distinguishes from sibling tools like register_agent and revoke_agent by focusing on listing.

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 identifies a prerequisite ('Requires API credentials') and implies usage for viewing registered agents. It doesn't explicitly contrast with siblings, but the context of sibling names makes the purpose clear.

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

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

No annotations provided, so description carries full burden. Discloses that secrets are never returned ('key ids and metadata; never the secrets') and auth method. Covers key safety aspects.

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

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

Two sentences, no extraneous words. Efficiently conveys purpose, scope, and authentication.

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

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

No output schema, but description specifies what is returned (key ids and metadata). For a simple list tool, this is adequate context.

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

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

Input schema has 0 parameters with 100% schema coverage. Baseline score of 4 for 0 params. No parameter info needed.

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

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

Description clearly states 'List the HMAC API keys for the authenticated wallet' – specific verb and resource. It distinguishes from siblings like create_api_key and delete_api_key.

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 authentication requirement: 'Authenticates with a session token from `login` — set NEXUS_EXCHANGE_SESSION_TOKEN.' Clearly indicates when to use but no explicit exclusions or alternatives.

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

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

With no annotations provided, the description carries the full burden and does disclose that this is a read-only operation scoped to the authenticated account and that API credentials are required. However, it doesn't disclose what happens when no deposit addresses exist, whether the output is a plain list or paginated, or any rate-limit/error behavior. Useful but not rich behavioral context.

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

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

One sentence, 10 words, front-loaded with the verb 'List' and zero filler. Every word adds meaning. The only micro-flaw is a slight redundancy ('cross-chain'...'across chains'), which is negligible.

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

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

This is a simple, parameterless list operation with no output schema, so the burden for completeness is low. The description adequately covers the purpose and the key prerequisite. It could marginally improve by noting the return behavior (e.g., empty list if none found), but it is complete enough for agents to invoke correctly.

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