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

No annotations are provided, so the description must stand alone. It discloses the tool is for scanning and finding largest spreads, which implies read-only behavior. However, it lacks specifics about data sources, update frequency, or any side effects. The description is minimally transparent.

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

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

Two sentences, no fluff. The first sentence states the purpose, the second clarifies the output. Extremely concise 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?

With no output schema, the agent doesn't know the return format. The description is adequate for a simple scan tool but could be more complete by indicating what fields each result contains (e.g., symbol, spread, exchanges).

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 parameter descriptions. The description adds value beyond the schema by stating the default value for minSpread (5) and clarifying that omitting symbols returns all. This helps the agent understand usage.

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

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

The description clearly states it scans for funding rate arbitrage opportunities and finds symbols with the largest spreads. It uses a specific verb ('scan') and resource ('funding rate arbitrage opportunities'), effectively distinguishing it from related tools like get_funding_rates or get_arb_compare.

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

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

The description implies usage for finding arbitrage opportunities but provides no explicit guidance on when to use this tool versus alternatives (e.g., get_funding_rates or get_arb_compare). No exclusion criteria or context for 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?

No annotations are provided, so the description carries the full burden. It mentions explaining parameters and risks, but does not disclose that the tool is read-only or any other behavioral traits. This is adequate but minimal.

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

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

Two sentences that are direct and front-loaded with the purpose. No extraneous words.

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

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

The description is adequate for a simple tool with one parameter, but lacks information about return values or output format. Given no output schema, more completeness would be beneficial.

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% parameter description coverage with examples. The description adds no additional parameter information, so baseline score 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's purpose: to explain what a perp CLI command does, its parameters, and risks. This distinguishes it from sibling tools like 'trade_execute' or 'suggest_command'.

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

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

The description implies usage context by stating it helps the user understand a command before running it. However, it does not explicitly list when not to use or alternative tools, though the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It states the tool compares positions but does not disclose whether it is read-only, requires authentication, or has any side effects. The name suggests a read operation, but the description does not confirm safety.

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

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

The description is a single sentence that efficiently communicates the tool's purpose and output. 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?

Given the tool has one well-documented parameter and no output schema, the description provides the essential purpose and the key metrics returned. It is adequate for a simple comparison tool, though it could mention the result format.

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

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

The single parameter 'period' is fully described in the input schema with valid values. The tool description adds no additional meaning beyond the schema, so the baseline score 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 verb 'Compare' and resource 'active arbitrage positions', and lists specific metrics (ROI, funding income, price PnL, annualized returns). This distinguishes it from siblings like get_funding_analysis or get_pnl_analysis.

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

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

The description implies usage for comparing arbitrage positions but provides no explicit guidance on when to use this tool versus alternatives like get_funding_analysis or get_positions. No exclusion criteria or context given.

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

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

With no annotations, the description carries the full burden. It partially meets it by disclosing the composition of the returned balance, but says nothing about authentication requirements, error behavior for unsupported exchanges, or whether the read is safe/cached. Adequate but with real gaps for an exchange-facing data 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 dense sentences, with the core purpose front-loaded and no wasted framing. The trailing reference to 'HIP-3 dexes via the CLI --dex' is brusque and assumes jargon knowledge, slightly reducing clarity for the space it occupies.

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 one-parameter read tool with no output schema and no annotations, the description compensates reasonably by naming the returned fields and one important scope limitation. It stops short of covering failure modes for unsupported exchanges or the shape of the response payload, but nothing critical for a successful call is absent.

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 single 'exchange' parameter and its alias list, making 3 the baseline. The description adds genuine parameter-tied meaning by warning that the hyperliquid value yields native perps only and that HIP-3 dexes require the CLI --dex path, which affects how the agent should interpret and use that value.

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

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

Names a specific verb and resource ('Get account balance') and enumerates the exact figures returned (equity, available margin, margin used, unrealized PnL), which separates it from position/portfolio-oriented siblings like get_positions or portfolio. The Hyperliquid scoping clause further pins down exactly what scope of balance this returns.

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

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

Usage is implied by the nature of the tool (read-only lookup of the account's balance on a given exchange), and the Hyperliquid caveat tells the agent one case where coverage differs. However, no alternative tool is named and no explicit when-to-use/when-not guidance is given, so the agent must infer whether to prefer this over portfolio or get_positions.

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, so the description carries the full burden and does: read-only, nothing signed, no key required; per-venue failure isolation into data.errors; error codes CAPABILITY_UNSUPPORTED and INVALID_PARAMS; null semantics for Lighter balances and spot; and the warning that Hyperliquid dex failures appear in meta.errors/meta.warnings as unknown rather than zero.

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 front-loaded: the keyless/any-address premise comes first, then venues, then the returned shape. It is long, but with no output schema the data-shape sentence earns its place; the parenthetical Lighter/Hyperliquid caveats could be tightened.

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

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

There is no output schema and no annotations, so the description must supply both the safety profile and the return shape — and it does, including per-venue null behavior, partial-failure reporting, and error taxonomy. An agent can call this correctly and interpret the response without further 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 coverage is 100%, so the baseline is 3; the description still adds meaning by mapping address formats to venues, explaining that omitting `exchange` fans out to every venue, and clarifying that `accountIndex` narrows an address that otherwise returns one row per Lighter account. Marginal but real added value over the schema text.

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

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

States a specific verb and resource (read balances) plus a scoping qualifier that separates it from the sibling get_balance: it works for ANY account by public address and requires no key. The venue list and keyless framing make the tool's identity 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?

Clear usage context: pass any public address, choose a venue or omit `exchange` to sweep all of them, and use `accountIndex` to narrow to one Lighter sub-account. It never explicitly contrasts with the sibling get_balance (own/configured account) or get_positions_by_address, so the routing signal is implied rather than stated.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It only restates the tool's purpose and outputs without mentioning any behavioral traits (e.g., read-only, no side effects, auth requirements). It does not contradict annotations (none exist), but adds minimal 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 sentences: the first states the tool's function and outputs, the second gives a use case. No redundant words, front-loaded with the main purpose.

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

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

The description explains what the tool returns (cumulative totals, annualized rates, per-arb-position breakdown), compensating for the lack of an output schema. It could detail how parameters affect analysis or the output format, but it is sufficient for an agent to understand the tool's value and general behavior.

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

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

All three parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The description does not add any meaning beyond the schema—it does not elaborate on period, exchange, or symbol usage. The schema already mentions period options and defaults.

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

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

The description clearly states it 'Analyze funding income across exchanges' and lists specific outputs (cumulative totals, annualized rates, per-arb-position breakdown). It distinguishes itself from siblings like get_funding_rates (which likely provides current rates rather than analysis) and get_pnl_analysis.

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

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

The description provides a clear use case: 'Great for tracking funding arb profitability.' This implies when to use the tool. However, it does not explicitly mention when not to use it or compare with alternatives like get_funding_rates or get_pnl_analysis.

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

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

With no annotations, the description carries the full burden and does substantial work: it defines the verified/unverified split, names the specific unverified venues and the reason each is unverified, and warns that unverified rows are 'display only, never a basis for trading'. It stops short of covering freshness/caching, pagination, or result-size 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?

Front-loaded with the primary purpose, followed by the conditional behavior and the safety caveat in a sensible order. The long parenthetical venue list makes the middle sentence dense and hard to parse, but every element carries information.

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

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

No output schema exists, and the description compensates by sketching the return shape (rates per symbol, spread analysis, per-row fundingVerified/apiStatus tags) and the verification semantics. Missing only secondary operational details such as snapshot timing or result limits.

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, but the description genuinely adds meaning for includeUnverified by enumerating which venues appear and why their rates are unverified — context not present in the schema blurb. symbols and minSpread are left entirely to the schema.

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

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

States a specific verb and resource: compare funding rates across venues, returning rates per symbol with spread analysis. An agent knows exactly what it returns, but nothing distinguishes it from close siblings like get_funding_analysis or arb_scan, which share the same domain.

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

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

Usage is implied by 'compare funding rates across every market-data venue whose funding rate is verified', and the CLI equivalence ('mirrors the CLI `arb scan --include-unverified`') hints at a workflow. However, there is no explicit when-to-use-this vs. get_funding_analysis/get_arb_compare/arb_scan guidance and no stated 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 behavioral burden. It does disclose a meaningful trait – no authentication required for public market data – plus an exchange-specific limitation, but it says nothing about result volume, pagination, rate limits, or response structure for a list-returning 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 short sentences with the core purpose front-loaded and no filler. The trailing Hyperliquid fragment is terse and slightly cryptic ('via the CLI --dex') but does not waste space.

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

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

For a one-parameter, read-only market-data tool with no output schema and no annotations, the description covers what is returned, the auth posture, and one exchange-specific constraint. Missing only return-count/pagination expectations and any sibling routing, which keeps it short of a 5.

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

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

The schema already documents the single exchange parameter at 100% coverage, which sets the baseline at 3, but the description adds real semantics by noting that behavior varies with the exchange value (Hyperliquid returns native perps only; HIP-3 dexes require the CLI --dex). That is meaningful guidance beyond the schema's alias list.

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

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

The description gives a specific verb and resource ('Get all available perpetual futures markets on an exchange') and enumerates the payload ('price, funding rate, volume, and max leverage'). That enumeration implicitly separates it from siblings such as get_prices, get_funding_rates, and get_orderbook, which return only one of these slices.

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

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

It states useful context for when this tool applies ('Works without API keys (public market data)') and a caveat for a specific exchange ('Hyperliquid: native perps only'), but it never names an alternative tool or says when NOT to use it. Usage is implied rather than routed.

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 read-like nature via 'Get' and adds a meaningful limitation for Hyperliquid (native perps only), but it omits other behavioral details such as authentication, rate limits, pagination, or return format. The added constraint is useful but the disclosure is incomplete.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a specific caveat. There is no redundant or filler text.

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

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

For a single-parameter listing tool with full schema description coverage and no output schema, the description is mostly complete. It explains scope and notes a key exchange-specific limitation, though it could mention return ordering or whether empty lists are possible.

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 even without additional parameter meaning. The description adds value by clarifying that the 'exchange' parameter includes Hyperliquid but only for native perps, with HIP-3 dexes requiring a CLI flag. This adds semantic context beyond the schema's list of exchange names.

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

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

The description states a specific verb ('Get') and resource ('all open/pending orders') scoped to an exchange. It is clearly distinguishable from sibling tools like get_positions, but does not explicitly name an alternative or contrast with one.

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 through 'open/pending orders' and provides a Hyperliquid-specific constraint, but it does not explicitly say when to use this tool versus related siblings such as get_positions or portfolio. The guidance is implied rather than stated.

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

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

With no annotations, the description carries the burden and does well: it declares 'Public read' (no auth, read-only), 'One venue request per expiry' (cost/latency characteristic), that decimals are strings, and that null means an empty side or non-computable IV. It stops short of describing pagination or any 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?

A single dense sentence, but it is front-loaded with the resource and scope and every clause carries payload (field list, null semantics, data format, request cost). The em-dash enumeration is heavy but not padded.

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?

There is no output schema, so the description must describe return content, and it does: rows per strike, call/put bid-ask-mark-index-forward-IV-greeks-OI-volume, plus the ATM strike. Combined with the schema-covered parameters and stated request cost, an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so venue, expiry, strikes, and underlying are already fully documented in the schema; baseline is 3. The description restates the expiry and ATM-reference concepts but adds no syntax or format meaning beyond what the schema supplies.

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

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

Names a specific verb+resource (option chain) and its scope (one expiry, one venue), then enumerates the row/column shape. It is clearly distinguishable from siblings like get_option_quote (single quote) and get_option_expiries (expiry list).

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

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

The scoping phrase 'for one expiry' implies when this tool applies versus get_option_quote/get_option_expiries, but no alternative is named and no explicit when/when-not guidance is given. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the burden and does so reasonably: it declares the tool is a public read requiring no API key, and specifies sort order ('soonest first') plus the fields returned per expiry. It stops short of pagination or rate-limit behavior, keeping it below a 5.

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

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

A single tight sentence, front-loaded with the action and resource, then the return contents and the read-only note. No redundant or filler clauses.

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

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

No output schema exists, and the description compensates by naming the returned fields and their order. Combined with full schema coverage and an auth note, an agent has enough to call it correctly; only sibling routing guidance is missing.

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

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

Schema description coverage is 100% for both parameters (venue, underlying), so the schema already does the documentation work. The description only lightly reinforces that the venue is Derive; 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?

States a specific verb+resource (list active option expiries) scoped to an underlying on a named venue (Derive), and enumerates the returned per-expiry fields. An agent can distinguish this from siblings like get_option_chain or get_option_quote without opening a schema.

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

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

Usage is implied by the listing/scoping language and the note that it is a public read, but the description never states when to choose this over get_option_chain or get_option_quote, nor any exclusion conditions. Adequate but leaves routing to inference.

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

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

With no annotations, the description carries the full burden and does well: it declares 'Public read' (no auth required), specifies the error contract (unknown instrument → SYMBOL_NOT_FOUND), and lists the returned field set. It omits any rate-limit or freshness/caching notes, which is the only meaningful gap.

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

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

Two tight sentences: the action and target are front-loaded, followed by a dense but scannable field list and the error/auth notes. No wasted prose.

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

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

For a two-parameter read tool with full schema coverage and no output schema, the description compensates by enumerating the returned fields plus the error and auth contracts. It is nearly complete; only freshness/rate-limit context is missing.

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

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

Schema description coverage is 100%, so both venue and instrument are already documented in the schema. The description restates the Derive naming convention example, which the schema already includes, adding no new semantic detail; baseline 3 applies.

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

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

States a specific verb (quote) and resource (one option instrument), and enumerates the returned data fields. The phrase 'one option instrument' implicitly separates it from the plural get_option_chain and get_option_expiries siblings, and the inline example makes the target unambiguous.

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

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

The word 'one' implies single-instrument lookup versus a chain-wide call, so usage is inferable. However, no sibling is named explicitly and there is no statement of when-not to use it, so the agent must infer the boundary with get_option_chain.

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

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

With no annotations present, the description carries the full burden and does well: it discloses credential-driven adapter routing, the keyless public fallback, read-only behavior, and a venue-specific limitation (Hyperliquid native perps only, HIP-3 dexes via the CLI --dex flag). It does not mention rate limits or the structure of what comes back, but the failure-mode disclosure is unusually strong for a read 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?

One dense front-loaded sentence states the core purpose first, then appends routing and venue caveats as clauses. Nothing is filler, though the trailing Hyperliquid/--dex note is cryptic and packed into the same sentence.

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

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

For a multi-exchange tool with no annotations and no output schema, the description covers routing and availability risks well, but it never characterizes the returned book (level structure, depth, price/size format). The agent knows whether the call will work but not what it gets back.

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 both parameters are already documented in the schema (symbol examples, exchange name list). The description adds only venue-specific semantics around exchange, not syntax or format beyond the schema. Baseline 3 applies.

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

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

The description states a specific verb and resource — retrieve the bids-and-asks order book for a given symbol/exchange — which is unambiguous on its own. It does not explicitly contrast itself with near siblings like get_prices, get_outcome_book, or get_option_chain, so an agent must infer the differentiation from the exchange/symbol scope.

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

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

It gives real usage context: works keyless on any venue with an account API, routes to the account adapter when credentials exist, and returns nothing on market-data-only venues. That is a clear when-it-works/when-it-fails statement. It stops short of naming an alternative tool for the cases it cannot serve.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add a useful auth detail ('Public read — no API key needed') and implies a read-only nature, but it omits other relevant traits such as return format, pagination, rate limits, or error behavior.

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

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

The description is two short sentences, front-loading the core action and then adding a key constraint. Every sentence earns its place, with no redundancy or filler.

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

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

For a simple read operation with a fully described schema and no output schema, the description covers the core purpose and auth requirement. However, given the presence of a similar sibling tool (get_orderbook), it lacks the usage guidance and behavioral detail that would make it fully self-sufficient for correct invocation.

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

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

Schema description coverage is 100%, and the schema already provides thorough descriptions for both parameters (including side index semantics and outcome id examples). The description adds no additional parameter-level meaning beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource ('Get the orderbook') and narrows scope to 'one outcome side', which helps distinguish it from the sibling get_orderbook. However, it does not explicitly name or contrast with that sibling, so the differentiation is implicit rather than explicit.

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

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

The description offers no guidance on when to use this tool versus alternatives like get_orderbook or other outcome-related tools. It only states what the tool does, leaving the agent to infer appropriate usage from context alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose two useful traits: it is a public read requiring no API key, and it returns parsed metadata plus per-side info (Yes/No name, encoding, asset id, mid). It does not mention pagination, rate limits, or whether inactive/expired markets are excluded beyond the word 'active'.

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

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

Two tight sentences with zero filler. The purpose is front-loaded, followed by the payload shape and the auth note, so an agent gets everything in one pass.

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

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

With no output schema and no annotations, the description must carry the return-shape burden, and it does so reasonably by enumerating the parsed metadata and per-side fields. Minor gaps remain around pagination and whether results are exhaustive, but for a parameterless read this is close to 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 tool takes zero parameters, so there are no parameter semantics to document; the baseline for a parameterless tool is 4. The description correctly implies a no-argument, whole-list operation.

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

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

The description states a specific verb and resource: 'List active Hyperliquid Outcome markets (HIP-4)'. This clearly separates it from get_outcome_book, get_outcome_view, and get_outcome_positions, which operate on a single market or positions rather than enumerating markets. It stops short of explicitly naming the sibling it replaces or complements (e.g. get_markets), so it falls just short of a 5.

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

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

Usage is implied rather than stated: an agent can infer this is the entry point for discovering outcome markets before drilling into one. The only explicit guidance is 'Public read — no API key needed,' which tells the agent it can call freely. No when-not-to-use or alternative routing is given.

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

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

With no annotations, the description carries the full burden. It discloses the auth prerequisite and the returned shape, and 'Get' implies a safe read, but it omits error behavior, empty-state handling, and rate-limit 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?

Two tight sentences, front-loaded with purpose and return fields, ending with the one hard constraint. Every clause earns its place.

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

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

No output schema exists, but the description enumerates the key return fields and the wallet precondition, which is largely sufficient for a no-arg getter. Minor gaps remain around empty/error states.

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

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

Zero parameters, so the baseline is 4. The description correctly adds no parameter discussion and instead spends its words on return fields and prerequisites.

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

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

States a specific verb ('Get') and resource ('active account's open outcome positions'), and enumerates the returned fields. The 'outcome' qualifier implicitly separates it from the sibling get_positions, though no sibling is named 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?

The prerequisite ('Requires a configured Hyperliquid wallet or agent') is stated, which is useful context. However, there is no guidance on when to use this vs. get_positions or get_outcome_view, so usage is only implied.

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

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

With no annotations, the description carries the full burden and does disclose the access profile ('Public read') plus meaningful behavioral context about the binary-market symmetry (Yes bid + No ask ≈ 1.0) and the round-trip efficiency. It omits pagination/rate-limit and error behavior, so it is strong but not exhaustive.

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?

Front-loaded with the core action and the enumerated outputs; the binary-market example earns its place by clarifying the domain. Dense and slightly run-on, but no sentence is pure filler.

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

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

No output schema exists, so the description must explain returns, and it does enumerate the view's contents and the market semantics. Combined with 100% schema coverage for parameters, the agent has enough to call it correctly, though it lacks any error or freshness caveats.

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

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

Schema description coverage is 100% and both parameters (outcome, depth) are documented inline, so the baseline is 3. The description adds conceptual framing ('underlying mark price gap vs targetPrice') but no extra syntax or format meaning for the parameters themselves.

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

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

States a specific verb (Get) and resource (combined view of one outcome market) and enumerates the components returned: all sides' books, mark price gap, time to expiry, and per-side implied probability. The 'all sides in parallel' and 'single round-trip' phrasing implicitly separates it from single-sided siblings like get_outcome_book, but it never names an alternative 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?

Usage context is implied ('exposes both sides in a single round-trip and surfaces directional context') rather than stated as a when-to-use rule. No exclusions or alternative-selection guidance are given, so the agent must infer the scenario from the described output.

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 reveals the tool combines two data sources and outputs a breakdown, but doesn't disclose whether it's a read-only query, any prerequisites (e.g., historical data availability), or refund/rate limit constraints. Adequate but not exhaustive.

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

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

Single, well-structured sentence that front-loads the core functionality ('P&L analysis combining...') and includes key details (by exchange, daily breakdown). 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?

No output schema, but description adequately explains what is returned (net profit/loss, daily breakdown, by exchange). Parameters are simple (period, exchange filter). For a moderately complex analysis tool, this provides sufficient context for an agent to use it correctly.

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

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

Schema coverage is 100% with clear parameter descriptions (period options listed, exchange filter). The description adds no extra 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 performs P&L analysis combining trading fees and funding income, showing net profit/loss by exchange with daily breakdown. It effectively distinguishes itself from sibling tools like get_funding_analysis (which likely focuses solely on funding) and get_balance (balance vs P&L).

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

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

No explicit guidance on when to use this tool versus alternatives like get_funding_analysis or get_positions. The description only implies it for net P&L overview, lacking when-not or alternative recommendations.

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

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

No annotations are supplied, so the description carries the full disclosure burden. 'Get ... positions' plus the returned-field list makes the read-only nature reasonably clear, and the exchange-scoping caveat adds real behavioral context. However, it says nothing about authentication requirements, whether an empty result is returned when no positions exist, or rate/latency behavior for a live trading-data call.

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

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

Two sentences, no filler, and the core verb-resource statement is front-loaded ahead of the exchange-specific caveat. Every clause earns its place.

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

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

With no output schema, the enumeration of returned fields compensates well, and the exchange-specific limitation prevents a common misuse. Given a one-parameter read tool this is close to complete, though a note on the empty-result case and on sibling differentiation would close the remaining gap.

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

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

Schema description coverage is 100% and the single 'exchange' parameter is fully documented with an accepted-values list, so the baseline is 3. The description adds only the Hyperliquid-specific qualification about which position types are covered, which is a modest addition over the schema.

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

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

States a specific verb and resource ('Get all open positions on an exchange') and enumerates the returned fields (size, entry price, PnL, leverage), so the agent knows exactly what it retrieves. It does not, however, explicitly contrast itself with the closely-named siblings get_outcome_positions or pacifica_print_positions, which an agent could easily confuse with it.

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 Hyperliquid caveat ('native perps only; HIP-3 dexes via the CLI --dex') is a useful scoping constraint. But there is no guidance on when to prefer this over get_outcome_positions, pacifica_print_positions, or get_balance, leaving the sibling choice implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden; it discloses read-only/keyless behavior, venue-specific semantics, Hyperliquid HIP-3 dex inclusion and error reporting, Lighter multi-account rows, and specific error codes. This is unusually rich behavioral context beyond the schema.

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

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

Front-loads purpose and then packs venue support, return nuances, and error codes into a single dense paragraph. Most content earns its place, though 'keyless, read-only' and 'nothing is signed, no key is needed' are mildly redundant.

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

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

For a complex multi-venue tool with no output schema, it supplies supported venues, address formats, row-level nuances, and error codes, but does not enumerate full position row fields. That leaves some return-shape detail implicit, so 4 rather than 5.

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

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

Schema coverage is already 100%, so the baseline is 3; the description adds venue-specific address formats (including risex) and clarifies that accountIndex narrows Lighter results across all accounts of an address. It does not need to repeat every schema 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?

States a specific verb and resource ('Open positions'), scope ('ANY account by its public address'), and safety mode ('keyless, read-only'), which clearly separates it from account-bound siblings like get_positions. It also enumerates supported venues.

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

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

Explains the primary use case (querying any account by address without a key), lists supported venues and address formats, and names failure modes for unsupported venues and malformed addresses. It does not explicitly route agents to the sibling get_positions for their own account, so not 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 and no output schema, the description carries the full burden; it does disclose useful behavior — prices are mark prices, a venue only appears in a row when it lists the symbol (with the QFEX/BTC example), and unofficialApiVenues flags undocumented-API venues. It still leaves the row structure and other returned fields unexplained, which matters given the absent 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?

Purpose is front-loaded in the first sentence and the three sentences are dense but mostly load-bearing. The trailing 'like get_markets' venueApi tag' comparison and '(none at present)' aside are mild clutter but do clarify a returned field.

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 annotations and no output schema, the description explains venue-inclusion semantics but not the shape of returned rows (fields beyond unofficialApiVenues, price format, missing-symbol handling). An agent can call it, but cannot fully anticipate the response.

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

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

Only one optional parameter and schema coverage is 100%, with the schema already stating the example symbols and the 'omit for top assets' default. The description adds no syntax, format, or normalization details beyond what the schema provides, so baseline 3 applies.

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

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

Specific verb+resource: 'Get cross-exchange prices for symbols', and it clarifies these are mark prices aggregated from every venue, which distinguishes it from single-venue tools like get_orderbook. It never explicitly names which sibling to use instead, but the resource and scope are unambiguous.

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

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

Usage is implied ('for comparison', cross-venue) but there is no explicit statement of when to prefer this over get_markets, get_orderbook, or get_funding_rates, and no exclusions. The get_markets analogy explains a field, not when to call this tool.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the per-venue probing method (REST ping for specific venues, public market-data read for others), the meaning of status values (HTTP status, 0 = no response, null), and that failures carry error messages. It omits layering such as rate limits or side effects on the venues, but 'ping' plus explicit read semantics make the safety profile unambiguous.

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?

Front-loaded with the core action and result in the first sentence, then per-venue mechanics, then the failure case. The venue enumeration is dense but each clause conveys distinct behavior; only the five-name list is slightly heavier than necessary.

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

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

With no output schema and no annotations, the description must convey the return shape, and it does — connectivity status, latency, per-venue status semantics, and error payloads. For a zero-parameter diagnostic tool this is nearly sufficient, though it could note whether results are keyed by venue name.

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

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

Zero parameters, so the baseline of 4 applies; there is no parameter surface for the description to explain or omit. Nothing in the prose misrepresents the empty input schema.

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

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

States a specific verb and resource — 'Ping every registered venue on the server's network and return connectivity status and latency' — and enumerates the exact venues covered. This clearly distinguishes it from all sibling tools, which fetch market data, balances, or execute trades.

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 diagnostic intent is implied by the name and description, so an agent can infer it is for connectivity checks. However, there is no explicit statement of when to call it (e.g., before trading, on suspected outage) or how it relates to alternatives among the siblings.

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

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

With no annotations, the description must carry the full behavioral burden. It usefully discloses read-only behavior and pagination via limit/cursor, and lists possible statuses, but it omits permissions, rate limits, error behavior, and return shape.

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 definition is front-loaded and compact, with no unnecessary background text. The trailing status list is terse and slightly cryptic, but it is relevant and does not bloat the description.

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 list tool with no annotations or output schema, the description covers the core retrieval behavior and pagination. It still leaves gaps around return fields, authentication or permissions, and how this tool relates to overlapping siblings.

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 50%, so the description should compensate for the undocumented limit and cursor parameters. It does clarify that limit/cursor are pagination controls and that history=true returns every order, but it does not explain cursor format, limit semantics, or the account parameter beyond what the schema already says.

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

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

The description states a specific read-only resource: orders for a Pacifica account, with a current-vs-history distinction. It is clear enough to identify the tool, but it does not differentiate the tool from close siblings such as get_open_orders or 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?

It gives a clear internal usage split: default current orders, or history=true for every order. However, it does not say when to choose this tool instead of sibling tools like get_open_orders or get_positions, so alternative routing is left implicit.

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

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

No annotations exist, so the description carries the full behavioral burden, and it does meaningful work: it declares read-only and explains the Print mechanic (resting orders fill or liquidate only at cycle checkpoints; after a fill it behaves as an ordinary perp with continuous liquidation). It omits auth requirements, rate limits, and pagination, so it is not exhaustive, but the domain mechanics are genuinely non-obvious 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?

Two sentences, front-loaded with the return payload and followed by the domain definition; no filler. The first sentence is a dense comma-separated run-on, which slightly hurts scanability but not substance.

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

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

With no annotations, no output schema, and no parameters, the description is the only source of information, and it supplies both the returned fields and the semantic model of a Print product. What it lacks is positioning relative to the sibling print tools, which is the main remaining gap.

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

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

The tool takes zero parameters, which sets the baseline at 4. The field list in the description describes returned data rather than inputs, and the empty schema is consistent with a no-argument read call, so nothing is missing or misleading.

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

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

States the resource (Pacifica Print products), marks it read-only, and enumerates the returns (game id, cycle length, max leverage, deposit caps, target distance). The verb is implicit ('returns') rather than explicit, and it never names the sibling tools (pacifica_print_quote, pacifica_print_positions) it must be distinguished from, so an agent must infer the split.

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

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

No when-to-use, when-not-to-use, or alternative routing at all. With three other print_* siblings in the toolset, the definition gives no signal that this is the discovery step preceding pacifica_print_quote. The domain gloss explains the product, not when to call the tool.

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

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

With no annotations, the description carries the full burden and does it well: it declares read-only/nothing-signed, discloses that the premium is NOT quoted (and why), and flags that the displayed liquidation price is a docs-formula outer bound with a caveat that a liquidation occurred in one live case while the venue trigger is unpublished. This is unusually candid about limits and side effects.

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

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

Purpose is front-loaded in the first clause, and each subsequent fragment (liquidation caveat, premium note, CLI alternative) is materially useful rather than filler. It is dense and dash-heavy with stacked parentheticals, which slightly hurts scannability, keeping it from a 5.

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

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

There is no output schema, so the description correctly compensates by listing the preview's returned fields and explaining the one field it omits. Combined with full schema coverage for the six inputs, an agent has enough to call it correctly; only finer return-shape detail (formats/margins) is absent.

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

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

Schema description coverage is 100%, so the schema already documents game, cycles, strike, deposit, leverage, and direction. The description adds context around what the call yields (e.g. max loss = deposit + premiums) but gives no per-parameter syntax or constraint detail beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb+resource ('Validate a Pacifica Print order and preview it') and enumerates exactly what the preview contains (notional, size on fill, liquidation price, max loss, lock period). It implicitly separates itself from sibling list tools like pacifica_print_products/pacifica_print_positions, but never names an alternative, so it stops short of a 5.

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

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

It clearly establishes the read-only preview context and, crucially, states that actually placing the order is CLI-only, pointing the agent to the alternative path and even noting --dry-run support. What's missing is any explicit routing against the MCP siblings (e.g. trade_preview), so it's clear context without named 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 present, so the description carries the full burden; it discloses read-only behavior, the unofficial/advisory deposit whitelist endpoint, that APY is null, and that mutations are CLI-only. It also explains error behavior for ambiguous nicknames and what data is returned in each mode.

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 front-loads read-only vault access and packs the relevant mode distinctions into a compact paragraph. It is dense with parenthetical details and semicolons, so it is efficient but not maximally readable.

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

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

Given no annotations and no output schema, the description does a lot: it names returned fields per mode, flags APY as null, and routes write operations to the CLI. The remaining gap is the exact account-plus-vault return behavior.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds useful semantics: vault accepts an address or exact nickname and ambiguous nicknames are rejected with candidates. It explains account as adding the account's shares, though the interaction between vault and account in vault mode is slightly under-specified.

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

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

States the resource (Pacifica vaults, API lakes) and the read-only retrieval operation directly, and distinguishes the three modes by whether vault/account are supplied. An agent can identify it as the vault-data tool, separate from balance, position, and order 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?

Explicitly describes when each mode applies: no vault lists every vault, account adds shares, and vault returns one vault with live details. It also warns that deposits/withdrawals are CLI-only and that ambiguous nicknames produce INVALID_PARAMS, giving clear when-not 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 supplied, so the description carries the full burden. It does disclose a real prerequisite (exchanges must have configured credentials) and the shape of the payload (balances, positions, risk metrics), but says nothing about read-only safety, behavior when an exchange lacks credentials, or the cost of fanning out across all exchanges. The read-only nature is only implied by 'summary'.

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 front-loads the resource and delivers scope and contents without a wasted word. Nothing to trim and nothing buried.

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

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

With no output schema and no annotations, the description is the sole carrier, and it does summarize the return contents (balances, positions, risk metrics) for a zero-parameter call. It is close to complete for a simple aggregation read; only the meaning of 'risk metrics' and empty/failed-credential behavior are left unstated.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey and the baseline of 4 applies. The description correctly adds no redundant argument talk.

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

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

The description names a concrete resource (portfolio summary) and enumerates its contents (balances, positions, risk metrics) plus its scope (cross-exchange, all exchanges with configured credentials). That scope wording implicitly separates it from single-purpose siblings like get_balance and get_positions. It stops short of 5 because no sibling is named explicitly to anchor the distinction.

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

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

There is no explicit when-to-use statement or any exclusion naming get_balance, get_positions, or get_pnl_analysis as narrower alternatives. The cross-exchange scope implies the use case (one aggregate view instead of per-exchange calls), which is enough for a 3 but leaves routing to inference.

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

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

With no annotations, the description carries the whole safety burden and does address the critical trait: it is read-only and returns commands rather than executing them. It does not say what the returned commands look like (flat strings vs. annotated steps) or whether it depends on configured defaults, which leaves a gap for a tool with no 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?

Two short sentences with zero filler; the core capability comes first and the non-execution disclaimer immediately follows where it matters most.

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

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

For a two-parameter suggestion tool with a fully documented schema, the description adequately conveys intent, scope, and the key side-effect stance. The only missing piece is the shape of the returned command output, which has no output schema to cover it.

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

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

Schema description coverage is 100% and the schema already explains both 'goal' (with examples) and 'exchange' (with default fallback and enumerated options). The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('suggest the exact perp CLI commands') driven by a natural-language trading goal, and the negation 'Does NOT execute anything' cleanly separates it from execution siblings like trade_execute. It never names an actual sibling (explain_command, trade_preview) to route against, so it stops short of full differentiation.

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

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

Use case is clear: turn a goal into commands for manual review rather than running them. The 'review and run manually' clause implicitly routes write-intent users to trade_execute, but no alternative is named explicitly and no exclusion cases 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 carries the full burden and does so well: it discloses that closedSize is a venue-final measured fill, that one residual market close is attempted, that a residual triggers ORDER_PARTIAL with symbol quarantine, and that Hyperliquid is native-perps-only. It omits what happens when no position exists and any permission/credential requirements, so not a 5.

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

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

Purpose and the pre-call requirement are front-loaded, and every sentence carries operational content. It is dense with internal jargon (ORDER_PARTIAL, uniform OrderResult, --dex) that costs some readability but is not padding.

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 2-parameter mutation tool with no annotations and no output schema, the description covers side effects, error mode, and return type adequately. Gaps are the no-position case and authorization expectations, which an agent may need before calling.

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 real constraint beyond the schema by narrowing the exchange parameter ('Hyperliquid: native perps only; HIP-3 dexes via the CLI --dex'). It adds nothing extra about symbol, but the exchange-side constraint justifies the bump.

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

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

States a specific verb and resource ('Close an existing position') and reinforces the mechanics ('reduce-only market order'), which clearly separates it from trade_execute/trade_preview. It stops just short of explicitly contrasting itself with the execute sibling by name.

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

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

Gives an explicit mandatory workflow: call trade_preview first with the opposite side, then obtain user confirmation. It names the alternative tool and the condition that selects it, leaving nothing to inference about ordering or approvals.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses that this is a real trade, that risk limits cannot be overridden over MCP, that orders are logged, and that quarantines affect opening orders. It also explains pending, rejected, and partial-fill outcomes in detail, including the critical 'do NOT resubmit' remediation.

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 long but front-loads the real-trade warning and preview requirement, and the length is justified by the tool's high-stakes behavior. Some sections are dense and could be split for readability, but little is wasted.

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

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

Given the absence of annotations and output schema, the description is remarkably complete: it covers network context, risk refusals, quarantine behavior, order logging, return shape, and outcome handling. An agent has enough information to call this tool correctly and interpret the main result states.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters clearly. The description adds high-level context such as market/limit support and reduce-only behavior during quarantine, but does not add parameter-level semantics beyond the schema.

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

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

The description states a specific verb and resource: execute a REAL trade on the server's network, and distinguishes it from the preview sibling by explicitly requiring trade_preview first. It also clarifies supported order types and that it returns a uniform OrderResult.

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 preconditions: always call trade_preview and get user confirmation before invoking. It also names refusal conditions (risk violations, quarantined symbols) and the alternative path for quarantined symbols (reduce-only orders only).

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

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

With no annotations the description carries the full burden and does so: it discloses that checks run read-only, that risk limits are "never forced," that refusals surface as valid:false with code + remediation, and that venue trading fees are NOT estimated. It also names exactly what is returned (fill price, notional, margin impact, builder fee, existing position).

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 key constraint (preview, no execution) is front-loaded, followed by the parity guarantee, the return payload, the negative caveat, and the mandatory-workflow instruction. No sentence is filler, though the middle sentence is dense.

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?

There is no output schema, so the description correctly enumerates the return payload itself, plus refusal semantics and venue limitations. Nothing an agent needs to decide to call it or interpret the result is missing.

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

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

Schema description coverage is 100%, so all eight parameters are already documented, and the description adds little parameter-specific meaning beyond echoing that TIF and reduce-only are "checked like trade_execute" — which the schema already says. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb and resource ("Preview a trade") and immediately negates the failure mode ("WITHOUT executing"), which cleanly separates it from the sibling trade_execute. An agent can pick it without opening the schema.

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

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

Gives an explicit imperative: "ALWAYS call this before trade_execute and show the result to the user for confirmation," which names the alternative and the ordering constraint. It also scopes the tool by venue ("Hyperliquid: native perps only, HIP-3 dexes via the CLI --dex").

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