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

With no annotations, the description carries the full behavioral burden. It discloses that the tool returns unsigned calldata only, implies no on-chain execution, and warns about prototype quality. This is meaningful context beyond what the tool name or schema conveys.

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 no filler. The critical prototype warning is front-loaded, followed by what the tool returns and the intended workflow. Every sentence adds value.

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

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

For a single-parameter scaffold tool with no output schema, the description covers the essential safety, output type, and workflow. It does not spell out the return encoding or deposit target specifics, but those are reasonably inferable from the tool name and sibling context.

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

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

Schema description coverage is 100%, and the schema already fully explains 'amount' as USDC native units in integer string form with 6 decimals. The main description adds no further parameter meaning, 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 states a clear verb and resource: 'Returns unsigned approve+deposit calldata.' This distinguishes it from siblings like build_order_tx, which handles orders, and from the various get_* tools. The prototype warning further narrows its identity.

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

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

It gives clear contextual guidance: 'PROTOTYPE ONLY', 'Simulate, then sign locally', and 'Not for production bots.' This tells an agent when it is acceptable to use the tool, though it stops short of explicitly naming alternative tools or exact conditions for choosing a different one.

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 safety burden. It discloses that the output is unsigned (implying no submission) and that the tool is prototype-only. However, it does not explicitly state whether the tool has side effects, validates inputs, or what errors may occur.

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, each carrying distinct information: prototype status, core output, preconditions, and production alternative. 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?

The description covers the tool's workflow position and prototype status, but leaves gaps in parameter formats, output details, and error behavior. For a tool with no annotations and no output schema, this is insufficient for an agent to call it correctly without additional investigation.

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 only 40%, and the description adds nothing about price, venue, timeInForce, or expirationAt formats. Required parameters like price are undocumented in both the schema and the description, so an agent cannot infer the expected string representation.

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: 'Returns unsigned createOrder calldata.' The 'PROTOTYPE ONLY' warning and the sibling build_deposit_tx make its role unambiguous and distinct.

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

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

Explicitly instructs to 'Run simulate_order and check_can_place_order first,' giving a clear precondition and ordering. Also states when not to use it ('Production bots encode via the npm ABI packages'), which routes production usage away from 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 provided, the description/extension carries the full burden of behavioral disclosure. It only mentions 'pre-trade gate' and parameter units, and omits any side effects, return type, whether it reverts, or if it modifies state. As a supervision tool it likely is a read-only check, but that is not stated.

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 one sentence, front-loaded with the contract signature and role, and the detail about additionalIM units. It has zero fluff, but the wording 'pre-trade gate' is opaque and could be more explicit about the tool's 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?

Given the presence of sibling tools like simulate_order and build_order_tx, and no output schema or annotations, the description is too terse. It fails to explain return type, how a decision is represented, or where to use this in a trade flow. The description is minimal for a 2-param tool in a complex batch of related tools.

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

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

The description adds that additionalIM is integer token units with USDC 6 decimals, which supplements the schema's description. However, the wallet parameter is left entirely undocumented, and since the schema describes only additionalIM, the description only partially compensates for the 50% coverage gap.

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

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

The description names the exact contract function 'PortfolioMarginEngine.canPlaceOrder(wallet, additionalIM)' and labels it 'the pre-trade gate,' which conveys that it is a predicate checking whether an order can be placed. It is clear enough to separate it from simulation or transaction-building tools, though it does not explicitly state the check outcome or contrast with siblings.

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

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

The phrase 'pre-trade gate' implies the tool should be used before placing or building an order, but there is no explicit instruction on when to use it versus simulate_order or get_margin_status. It does not mention when not to use it and gives no alternative routes.

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 states what data is returned but does not explicitly indicate that the operation is read-only, has no side effects, requires any specific authentication, or how it handles errors. The lack of any safety or side-effect information is a notable 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?

The description is a single, tightly worded sentence that front-loads the key return items and the environment scope. There is no filler or redundancy; every word contributes to the meaning.

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

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

For a simple no-parameter get tool, the description is fairly complete, but it lacks an output schema and does not describe the return format, potential error conditions, or how the environment is determined. An agent might not know exactly what keys or types to expect in 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?

The tool has zero parameters and the schema is empty, so the baseline is 4. The description adds relevant context about the 'configured environment' (testnet/mainnet), which clarifies the scope of the tool beyond the schema, though it does not add parameter-specific detail because none exist.

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

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

The description uses a specific verb ('Return') and clearly enumerates the exact data items (contract addresses, subgraph URLs, chain ID, ABI package versions), and scopes them to a configured environment (testnet/mainnet). This unambiguously distinguishes it from sibling tools like get_market_rules or get_orderbook, which cover different domains.

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

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

The description implies when to use it (when deployment information is needed) and adds context about the environment, but it does not explicitly state when to prefer this tool over alternatives or when not to use it. There is no mention of related tools or exclusions, leaving the routing decision to inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It explicitly says 'Read' and names the exact on-chain function, which makes it clear this is a non-mutating oracle read. It does not describe error handling or output format, but for a simple read the safety profile is well conveyed.

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 directly names the action, resource, and method. There is no filler or redundant restatement of the tool name, and the key information is immediately accessible.

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 oracle tool, the description plus the rich schema is nearly complete. The only notable gap is the lack of an explicit description of the return value, but the named Chainlink-style method strongly implies the returned round data.

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

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

The schema already fully documents the single `pair` parameter with an enum and a description, so the description adds no extra parameter-level meaning. The baseline of 3 is appropriate since schema coverage is 100%.

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 ('Read'), a concrete resource ('on-chain hashprice oracle'), and the exact oracle method used. This clearly distinguishes it from the sibling tools, none of which read the hashprice oracle.

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 communicates that this tool is for reading the current hashprice, which implies its usage context. However, it does not explicitly state when to use it over alternatives or mention any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only lists content categories and does not state whether this is a read-only query, how the rules are computed, whether they vary by contract, or what response format to expect.

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

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

The description is a single compact sentence with no filler or repetition. It is front-loaded with the core subject matter, though it is a noun phrase rather than a complete explanatory 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 zero-parameter tool, the description is minimally sufficient, but it does not explicitly state what the returned model looks like or how it differs from closely related siblings like get_margin_status. Some ambiguity remains about the exact deliverable.

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

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

The tool has zero parameters, so the baseline is 4. The description adds meaning by enumerating the conceptual areas the returned model covers, which is relevant context even though no parameter documentation is needed.

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

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

The description clearly identifies the resource as 'Portfolio margin / IM / MM / liquidation rules for perps and futures,' which is specific and distinguishes it from sibling tools like get_margin_status or get_market_rules. It lacks an explicit verb, but the title 'Get margin model' supplies the action.

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

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

No guidance is given on when to use this tool versus alternatives such as get_margin_status, get_market_rules, or get_positions. There are no usage conditions, exclusions, or sibling references, leaving the agent to infer applicability from the name alone.

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

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

With no annotations provided, the description carries the full burden. The '(eth_call)' disclosure is genuinely helpful behavior context: it tells the agent this is a read-only RPC with no state change and no transaction-building. However, it says nothing about edge-case behavior such as whether the call reverts for a wallet without a vault position, what happens with an invalid address, or whether results can be stale. It adds some meaningful disclosure but leaves important behavioral questions open.

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, tight fragment that front-loads the three return fields and tags the call type. There is no filler, and the '(eth_call)' parenthetical earns its place by conveying behavioral context. It loses one point only because it is a noun phrase rather than a complete sentence, so the verb must be inferred from the title.

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 tool, it covers what most agents need to call it correctly: the input (a wallet) and the outputs (balance, IM/MM, isHealthy). Given the domain, though, an agent would benefit from knowing how the isHealthy flag relates to check_can_place_order, whether IM/MM have units resolved by another tool, and what a missing position looks like. The absence of an output schema makes the description the sole source of return semantics, so it should say slightly more.

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

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

Schema description coverage is 100% – the schema already documents wallet as a '0x-prefixed EOA'. The description's 'for a wallet' adds nothing beyond that, so the baseline of 3 applies. It does not clarify semantic details like whether the wallet must hold an open position, how addresses are normalized, or what 'EOA' implies (no contract wallets), so no extra credit is earned.

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

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

The description specifies the resource (vault of a wallet) and enumerates the exact outputs (vault balance, portfolio IM/MM, isHealthy), which clearly differentiates it from the sibling get_margin_model (the model vs. a wallet's status). It lacks an explicit verb, but the title 'Get' supplies it and the content leaves little ambiguity. This is clear but just short of the best case because it relies on the title for the verb rather than stating it in the description.

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 guidance about when to call this tool versus alternatives such as get_positions, check_can_place_order, or simulate_order, nor any mention of prerequisites like having a vault position. The '(eth_call)' hint implies a read-only on-chain query, but the description never tells the agent whether to use it before building an order, after a deposit, or for account health checks. This is a clear 'no guidance' case.

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 behavioral disclosure burden and does so well by explaining the dual behavior (catalog vs. markdown fetch), citing the source endpoint, and giving concrete example slugs. It does not cover invalid-slug behavior or errors, but the main behavior is 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 dense sentences with no filler. The key usage pattern is front-loaded and every phrase adds value: source, dual mode, and concrete examples.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential invocation behavior and return type (markdown). It is complete enough for an agent to call correctly, though a note about invalid slugs or error handling would make it stronger.

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 adds meaningful semantics: the slug is optional, omitting it changes behavior to listing the catalog, and passing it fetches markdown. This goes beyond the schema's example-only parameter description.

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

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

The description clearly identifies the tool as retrieving agent-facing market semantics/rules and distinguishes the two modes: listing the catalog or fetching markdown for a specific slug. It is specific about the resource and usage, though it does not explicitly name or differentiate sibling tools such as get_margin_model.

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

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

The description gives clear context on how to use the tool: omit slug to list the catalog, pass a slug to fetch markdown. It does not state when not to use it or mention alternative sibling tools, but the usage pattern is explicit and easy to follow.

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

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

No annotations are provided, so the description carries the burden. It adds useful behavioral context: prices are on-chain CLOB prices, futures require expirationAt, and perps is a single book. However, it does not state that this is a read-only operation or describe response behavior like maxLevels limiting depth, leaving the agent to infer these.

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 terse, front-loaded sentences with no filler. Every clause earns its place: the core purpose, the futures requirement, and the perps distinction.

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 cover more ground. It handles venue differentiation and the expirationAt requirement, but it does not explicitly say expirationAt should be omitted for perps, say what maxLevels controls beyond defaults, or indicate the shape of the returned book. Adequate for basic invocation but with clear gaps.

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

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

Schema description coverage is only 33%, and the description compensates for the most important parameter by noting expirationAt's unit and conditional requirement. The venue enum and maxLevels constraints are in the schema, but maxLevels is not explained in the description, so coverage remains partial.

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

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

The description opens with 'On-chain CLOB prices,' which clearly identifies the resource (order book) and domain (on-chain CLOB), and the title supplies the verb. It distinguishes futures from perps, but does not explicitly differentiate from sibling tools, so it misses the top score.

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

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

The description gives concrete usage context: for futures, expirationAt is required; for perps, there is a single perpetual book. This tells the agent how to adjust calls based on venue, though it does not mention any alternatives or explicit when-not-to-use scenarios.

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

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

With no annotations provided, the description must carry full behavioral disclosure. It usefully clarifies that wallet is required and there is no session, implying a stateless read operation. However, it does not explicitly state it is read-only (important given transaction-building siblings), nor describe side effects, limits, or output format.

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

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

Two sentences with no filler; the first states the core purpose, the second clarifies the wallet parameter. Efficient and front-loaded, though slightly more detail could be added without becoming verbose.

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

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

For a tool with no output schema and no annotations, the description is incomplete. It omits the meaning of the venue parameter, does not explicitly state read-only behavior (important given siblings like build_order_tx), and gives no indication of the return structure. An agent would need to infer or probe to understand full 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 description coverage is 50%: wallet is described as '0x-prefixed EOA', but venue only has an enum and default with no semantic explanation. The description adds nothing about venue meanings or how it affects results, failing to compensate for the undocumented parameter.

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

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

States a specific verb (get) and resource (positions and resting orders) scoped to a wallet, sourced from public subgraphs. This distinguishes it from market-wide siblings like get_orderbook, though it doesn't explicitly name any alternative.

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

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

No guidance on when to use this tool versus alternatives. The description only states what it does, not when it should be preferred over siblings like get_margin_status or get_orderbook, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a read-only lookup, whether it returns data for a single market or all markets, whether it requires prior context like a selected market, or what the response shape is. The fragment 'Oracle decimals, futures contract unit/ticks, and perps QUANTITY_DECIMALS / order scaling' hints at the data returned but not the 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 very short, which is good, but it is a fragment rather than a complete sentence and lacks a leading verb. It front-loads the key terms but does not structure them into a clear statement. It earns points for brevity but loses points for grammatical incompleteness.

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

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

Given there is no output schema and no annotations, the description is the only source of information. It names several data categories but does not explain how they relate, whether the tool returns a combined object or separate values, or how an agent should use the result. For a zero-parameter tool, the description should at least state the return shape or the intended use case.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds some semantic value by naming the categories of data returned (Oracle decimals, contract unit/ticks, QUANTITY_DECIMALS/order scaling), which helps an agent understand what the no-argument call will produce. Baseline 4 for zero-parameter tools is appropriate.

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

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

The description lists several distinct concepts (Oracle decimals, futures contract unit/ticks, perps QUANTITY_DECIMALS / order scaling) without a single clear verb or resource. It reads as a fragment rather than a sentence, so an agent can infer it returns some unit/scaling configuration, but the purpose is not crisply stated. It is not a tautology, but it lacks a clear action like 'Get' or 'Return' and does not explicitly distinguish itself from siblings.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list includes get_market_rules, get_margin_model, and get_deployments, which could plausibly overlap with market configuration data, but the description does not mention any of them or provide selection criteria. An agent would have to guess whether to call this or a sibling.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is an on-chain read-only view, that it does not place or modify an order, and clarifies the buy/sell sign convention — all core behavioral traits. It omits peripheral details like authorization or response behavior, but the non-mutation guarantee is front-loaded and clear.

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

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

Two sentences, roughly 30 words, with the purpose question front-loaded before the sign convention and non-mutation warning. Every sentence earns its place; there is no filler or restatement of the title.

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 output schema, no annotations, and 11 siblings, the description covers the core intent but leaves several invocation details to inference: no hint of what the returned fill/average data will look like, no mention of the venue/expirationAt interaction, and no explicit distinction from check_can_place_order. Adequate and workable, but there is clear room to improve.

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 75%, and the schema itself already documents price, quantity, and expirationAt with useful descriptions. The description adds the concrete sign convention (positive qty = buy, negative = sell), which goes slightly beyond the schema's generic 'signed quantity', but it does not compensate for or clarify the remaining parameters beyond what the schema states.

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

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

States a specific verb+resource (simulate an order) and immediately answers the two key decision questions: would it fill, and at what average price. It also explicitly says 'Does not place an order,' which separates it from sibling order-building tools like build_order_tx, so an agent can tell it apart without opening schemas.

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

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

Usage context is only implied: the simulate-vs-execute distinction is hinted by 'Does not place an order,' but no sibling is named and no when/when-not guidance is given. Given siblings include check_can_place_order and build_order_tx, explicit routing would meaningfully help, so the definition meets only the 'implied usage' bar.

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