CoinCryptoRank MCP

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 the tool adjusts a hedge leg, but it does not explain the impact on the hedge, whether rebalancing occurs, how the other leg is affected, or any side effects. For a mutating tool, this is a significant transparency 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 short, front-loaded with the core purpose, and easy to scan. The action list is useful, though the 'Params:' line largely duplicates information already present in the input schema, which slightly reduces the value of that 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 mutating tool with no annotations and no output schema, the description leaves out important context: what each parameter represents, what happens after the adjustment, and when this tool should be selected over siblings. It is a minimal summary rather than a complete operating guide for an agent.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning beyond names. It merely lists 'positionId, action, sizeUsd' with no semantics for positionId or sizeUsd, and the action enum values are already visible in the input schema. This adds minimal value beyond the schema.

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

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

The description clearly states the tool adjusts one leg of a hedged position, which distinguishes it from sibling tools like open_hedged_position and close_hedged_position. It also enumerates the supported action values, making the tool's scope concrete. However, it doesn't explicitly name or contrast these siblings, so it falls just 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?

The description gives only implied usage context: this is for adjusting one leg of a hedge rather than opening or closing the whole position. It provides no explicit guidance about when to use this tool versus alternatives like open_hedged_position, close_hedged_position, or set_hedge_protection, and no exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the agent responds with strategy, live data, and tools, which is useful. However, it does not mention whether the chat has side effects, whether the agent can take actions, or any response limitations such as streaming or token limits.

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

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

The description is a single, well-structured sentence with the main action front-loaded and the explanatory context in a parenthetical. Every word earns its place, and there is no repetition of schema field names.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential context: the interaction model (free-form conversation) and the nature of the response (strategy, live data, tools). It lacks details like error behavior or conversation history, but these are minor for such a straightforward tool.

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

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

Schema description coverage is 100%, so the input schema already documents both parameters well. The description adds little beyond the schema: 'your agent' maps to the `agent` parameter and 'message' to the `message` parameter, but there is no additional semantic depth such as format, constraints, or typical usage for either parameter.

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

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

The description clearly states a specific verb ('Send a message') and resource ('your agent'), and it explains the conversational nature with the parenthetical. It is clear about what the tool does, but it does not explicitly distinguish itself from sibling tools like agent_trigger or agent_status, so it falls 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?

The phrase 'free-form conversation; it answers with its strategy, live data and tools' implies a conversational use case, which helps an agent know when to use it. However, it does not explicitly state when not to use it or name alternatives such as agent_status or agent_trigger, leaving the decision partially 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?

No annotations are provided, so the description carries the full burden for behavioral context. It implies a read operation that returns an agent's decision log, but it does not state side effects, whether the operation is safe, ordering, time range, or whether the agent identifier must be exact. This leaves important behavioral aspects undisclosed.

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

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

The description is a single concise sentence with no redundant words. It front-loads the core resource ('recent decisions/log') and lists key fields in parentheses, making it easy to parse.

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

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

For a simple read tool, the description gives a reasonable sense of return content and the schema covers parameter semantics. However, with no output schema and no annotations, it leaves out return shape (e.g., whether it is a list), ordering, and time window, so it is adequate but not fully 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?

Both parameters are fully documented in the schema: agent as 'Agent id or name substring' and limit with default/max values. The description does not add any extra parameter-level insight, so the baseline of 3 is appropriate given 100% schema description coverage.

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

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

The description identifies the resource as 'recent decisions/log' for a specified agent and lists the returned fields (status, trigger, summary, reply), making it clear this retrieves a decision log. It lacks an explicit verb like 'retrieve' or 'list', but it is distinguishable from siblings such as agent_status and agent_trigger by focusing on the full decision record.

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 related tools like agent_status or agent_trigger. The description does not mention alternatives, exclusion conditions, or any decision criteria for selection.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Get' strongly signals a read-only operation, but the description does not explicitly state that no state is modified, nor does it mention behavior around ambiguous substring matches or response format. It adds some context by listing returned fields, but leaves safety guarantees implicit.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently states the resource, the action, and the returned fields, making every word meaningful.

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

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

For a simple single-parameter read tool, the description plus schema is mostly complete: it names the target resource and the fields returned. However, with no output schema and no annotations, details like response shape and behavior when multiple agents match the substring are left unspecified, which prevents a perfect score.

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

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

Schema coverage is 100% and already documents the single parameter as 'Agent id or name substring'. The description adds no new parameter semantics beyond the phrase 'one of your agents', so it does not improve on what the schema already provides. 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 uses a specific verb ('Get') with a clear resource ('one of your agents') and enumerates the exact details returned (mode, status, risk, triggers, last activity). This differentiates it from siblings like list_agents (which lists all agents) and get_agent_events (which focuses on events).

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

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

The description implies use when inspecting a single agent's current configuration or status, but it does not explicitly state when to prefer this tool over related siblings such as get_agent_events, agent_trigger, or hedge_status. There are no exclusions or alternative-routing hints.

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?

There are no annotations, so the description carries the full burden of disclosing side effects and behavior. It says the tool 'runs' a trigger and returns a decision, but does not clarify whether this mutates state, places orders, requires prerequisites, or is a read-only evaluation.

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

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

One sentence with no filler. The arrow-separated trigger chain compactly communicates the execution order, and the return value is stated succinctly.

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?

Without an output schema, the description should clarify what the returned decision looks like, and without annotations it should clarify side effects. It does neither, leaving an agent to guess at the decision format and any consequential 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?

The single parameter 'agent' is already fully described in the schema as 'Agent id or name substring' at 100% coverage. The description only reinforces that the trigger belongs to an agent without adding new semantic detail, so the baseline score 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 names a specific action ('Run') and resource ('the agent's selected trigger'), and specifies a trigger chain (interval → news → trading signal) before returning a decision. This is clear on its own, though it does not explicitly contrast with sibling tools like agent_chat or agent_decisions.

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 about when to use this tool versus alternatives such as agent_decisions, get_news, or get_basis_signal. The intended context is only vaguely implied by the trigger-chain phrase, with no exclusions or decision criteria.

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

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

With no annotations, the description carries the full burden. It discloses the calculation method (min of both legs depth within slippage), provides a default for slippagePct, and implies a read-only analysis tool. However, it does not explicitly state it performs no state changes or whether it requires network access or permissions.

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

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

The description is a single concise sentence followed by a parameter list. The key output is front-loaded ('Orderbook liquidity'), and the parameter list is compact. No filler or redundancy, though it could be slightly more structured with explicit parameter explication.

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

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

The tool has 4 parameters, no output schema, and no annotations, yet the description omits the exact structure of the returned data, error conditions, exchange identifier formats, or how the recommendation is computed. An agent may struggle to interpret the output or handle edge cases.

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

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

Schema description coverage is 0%, so the description must explain parameters. It lists exchangeA, exchangeB, symbol, and slippagePct with a default, and the phrase 'within slippage' clarifies slippagePct. However, it does not define what symbol should be (e.g., a trading pair string) or specify exchange naming conventions, so it only partially compensates for the missing schema descriptions.

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

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

The description states a specific resource ('hedged pair') and the concrete outputs ('max neutral size', 'best prices', 'recommendation'). It distinguishes this from siblings like get_orderbook by focusing on cross-exchange pair analysis rather than a single orderbook.

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

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

No guidance on when to use this tool versus alternatives such as get_orderbook or open_hedged_position. It does not mention conditions, prerequisites, or exclusions, leaving the agent to infer appropriate usage from the tool name and context.

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

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

With no annotations, the description must carry behavioral transparency. It lists outputs but provides no information about side effects, permissions, read-only status, rate limits, or error behavior. The only behavioral hint is that it uses 'REAL funding archive', which is not sufficient for a clear understanding of the tool's 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?

The description is concise, consisting of one purpose sentence and a parameter list. It front-loads the main function and does not waste words, making it easy to parse.

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

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

The description covers purpose and outputs, but lacks essential context such as parameter semantics, error handling, output format, and any prerequisites or side effects. Given the absence of annotations, this is insufficient for an agent to fully understand how to use the tool reliably.

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 lists the parameter names ('exchangeA, exchangeB, symbol, days (max 90), sizeUsd') but does not explain their roles. It provides a constraint for 'days' (max 90) but leaves the meaning of exchangeA/exchangeB, symbol, and sizeUsd undefined. Since the schema has no parameter descriptions, the tool description only partially compensates.

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

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

The description clearly states the tool's function with a specific verb ('Backtest'), the resource ('funding-harvest strategy S2 on our REAL funding archive'), and the expected outputs ('gross/net %, annualized, winrate, max consecutive negative periods, verdict'). This distinguishes it from sibling tools that fetch data or signals.

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 that this tool is for backtesting, but it does not explicitly state when to use it over alternatives (e.g., get_funding_rates, get_basis_history) or provide exclusions. Usage must be inferred from the purpose, which is clear but not explicitly contrasted with other tools.

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

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

With no annotations, the description carries the behavioral burden. It discloses useful traits: both legs are closed, orders are market, and the operation is reduce-only. However, it does not mention side effects, failure modes, irreversibility, or permission requirements, which are relevant for a position-closing mutation 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?

The description is short and front-loaded, with the primary action and key execution mode in a single sentence. The 'Params: positionId, reason (optional)' tail is slightly redundant with the schema, but it is not bloated.

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 core behavior but omits important context for a financially risky operation: whether the position must already exist, what happens if one leg fails, whether the operation is reversible, and what the return value contains. It is adequate for a simple close action but not fully complete.

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

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

Schema description coverage is 0%, so the description should compensate by explaining what 'positionId' refers to and what 'reason' is used for. It only lists the parameter names and marks 'reason' as optional, which adds little beyond what the schema already shows.

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 ('Close'), a clear resource ('hedged position'), and adds execution details (both legs, market, reduce-only) that differentiate it from the sibling 'close_position'. An agent can confidently identify what this tool does without inspecting 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?

The term 'hedged position' implies when to use this tool, but the description does not explicitly say when to prefer it over 'close_position' or 'adjust_hedge'. It provides implied usage context but no direct exclusions or alternative 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly lists the sequence: market reduce-only order, cancellation of exchange SL/TP orders, and recording of realized PnL. It also state the return payload. This goes well beyond the schema and makes the side effects clear. It does not mention failure modes or partial-execution scenarios, but the core behaviors are adequately documented.

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: the first states the action and its sub-steps, the second lists the parameters and return. It is front-loaded with the main purpose and has zero filler. Every clause contributes to understanding the tool's function, making it appropriately concise and well structured.

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

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

For a tool with only two parameters and no output schema or annotations, the description covers the action, the methodological steps, the return value, and provides parameter examples. It is notably incomplete in documenting error handling or prerequisite checks (e.g., whether an open position must exist). However, these are relatively minor given the simple parameter surface, and the description provides sufficient information to invoke the tool correctly in most agent scenarios.

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 provides no descriptions for the two parameters (exchange and symbol), and coverage is 0%. The description compensates by giving an example for symbol ('BTC_USDT') and implicitly limiting exchange to the platforms mentioned earlier (binance/bingx/bybit). It does not enumerate exact allowed exchange values or fully specify symbol formatting, but it provides enough semantic context for an agent to form correct inputs. The description adds moderate value beyond the schema.

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

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

The description clearly states the specific action: closing an open position from the user_positions registry. It details the mechanism (market reduce-only), secondary operations (cancel exchange SL/TP, record realized PnL), and the return value (fill price and PnL). This distinguishes it from sibling tools like place_order (generic order placement) and close_hedged_position (which targets hedged positions specifically).

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

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

The description clearly indicates when to use this tool: when closing an existing position in the user_positions registry. It implies this is the preferred tool for closing positions (as opposed to opening or hedging), and the reduce-only caveat further clarifies scope. However, it does not explicitly name alternative tools or state 'do not use this for opening positions', leaving some OUSAGE inference to the agent. The context is strong enough for correct routing.

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 of behavioral disclosure, yet it only states what the feed contains and does not indicate read-only status, auth needs, pagination, sorting, or behavior when positionId is omitted. It adds context about event types but not enough about how the tool behaves.

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

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

The description is a single efficient sentence with the core purpose front-loaded and parameter notes appended. Every word earns its place.

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

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

The tool is simple and the description covers purpose and parameters adequately. However, without an output schema or annotations, the absence of return-shape details and behavior for an omitted positionId leaves meaningful gaps for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It does name both parameters and adds the useful default of 30 for limit and the optionality of positionId, but it omits further semantics such as value bounds, formats, or what happens when positionId is not provided.

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

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

Description names a specific resource ('engine event feed') and scopes it to a position, with a concrete list of event types (slices, funding collected, alerts, liquidation). This is specific enough to distinguish it from sibling agent tools such as agent_status or agent_decisions.

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 context of use is implied: retrieve the event feed for a position. However, there is no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives among the many sibling tools, so the agent must infer selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses useful behavioral details: minute-level granularity, 'buyPrice vs sellPrice,' data from 'our archive,' and hours default/max. However, it does not mention the return shape, data ordering, or potential limitations/errors, leaving some ambiguity for an agent.

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 appropriately sized and front-loaded: a single clear sentence describing the tool's purpose followed by a compact parameter list. There is no filler, and the example symbol adds value without bloat.

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

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

Given the tool has no output schema and no annotations, the description covers the essential context: data source, granularity, pair of exchanges, and parameter constraints. It stops short of fully specifying the output format or edge-case behavior, but is largely complete for a simple read-only history endpoint.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains all four parameters: exchangeA and exchangeB as the two exchanges, symbol with a concrete example ('HOME_USDT'), and hours with default (6) and max (48). This provides meaning far beyond the bare schema property names.

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

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

The description clearly identifies the action ('get') and the resource ('minute-level price basis history between two exchanges for the same perp symbol'), and adds specificity with 'buyPrice vs sellPrice from our archive.' It does not explicitly name sibling tools like get_basis_regime or get_basis_signal, so it is clear but lacks explicit sibling 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?

Usage is implied rather than stated: the description implies this tool is for fetching raw basis history between two exchanges, but it gives no explicit guidance on when to use it over similar siblings (e.g., get_basis_regime, get_basis_signal) or when not to use it. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden and does disclose the computational outputs and the signal's possible enum values. It does not mention data-window assumptions, exchange/symbol availability, errors, or whether this is purely read-only, but the getter name and analytical output list make major surprises unlikely.

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 dense sentence followed by a minimal parameter list. Every phrase adds useful information, and the output enumeration is front-loaded.

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

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

For a tool with no output schema and no annotations, the description names the returned metrics and signal values, which is helpful. It stops short of full completeness by omitting return shapes, typical lookback/defaults, and any differentiation from sibling basis 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 schema provides no descriptions for the three string parameters, so the description must compensate. It adds that exchangeA and exchangeB are the two sides of the basis spread and that symbol identifies the market, but it gives no format, allowed values, or exchange identifier conventions.

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 what the tool produces—basis regime statistics between two exchanges, including mean/std/z-score/percentiles, trend, oscillation score, and signal. It is specific about the resource and outputs, but it does not explicitly differentiate itself from the closely related get_basis_signal and get_basis_history siblings.

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

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

The description implies it should be used when an agent needs a quantitative regime summary and trading bias for a pair of exchanges. However, it does not state when to prefer get_basis_signal or get_basis_history instead, so the guidance is only 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?

With no annotations provided, the description must carry the full behavioral burden. It only lists return types and parameters, but does not disclose whether this is a read-only operation, any external calls, error conditions, or typical side effects. The absence of such details leaves significant uncertainty.

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 core purpose and outputs. Every word contributes; no fluff. It could add more detail without harming conciseness, but as it stands it is tightly structured.

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

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

Without an output schema, the description must clarify the return structure, but it only lists field names without defining them (e.g., what does z-score mean? what values can signal take?). Similarly, it does not explain maxNeutralUsd or the recommended action. An agent would still be guessing about expected 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 0%, so the description must compensate. It merely lists parameter names and marks maxSizeUsd as an optional cap, which barely extends the schema. It does not explain what exchangeA/exchangeB represent, what symbol means, or how maxSizeUsd affects the signal.

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 combined purpose ('basis regime + liquidity check') and lists concrete outputs (signal, z-score, maxNeutralUsd, recommended action). This clearly differentiates it from siblings like get_basis_regime and analyze_pair_liquidity which each cover only one aspect.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when it is the right choice, or any exclusions. An agent cannot infer when to pick this over get_basis_regime or analyze_pair_liquidity.

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 behavioral burden. 'List' signals a read operation, and 'availability for YOUR connected exchange keys' signals that results are key-dependent. However, it does not state what happens when no keys are connected, whether external calls are made, or any failure/rate-limit behavior.

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

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

The description is one dense, front-loaded sentence that states the action and resource immediately and supports it with concrete exchange examples. The final clause is slightly redundant with the availability point made earlier, but the overall length is reasonable and every piece of information earns its place.

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

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

For a parameterless listing tool with no output schema, the description adequately explains what the agent receives: a list of aggregated exchange MCP servers and skill libraries with availability for its connected keys. It does not detail the exact response format, but the use case is simple enough that this is not a critical omission.

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 already covers 100% of parameter documentation, so the description has no obligation to explain arguments. The output-oriented phrase 'tells an AI client which exchange skills it can actually use' adds useful context without conflicting with the empty schema.

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

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

The description begins with the verb 'List' and names a specific resource: official exchange MCP servers and AI skill libraries, with concrete examples (Binance, BingX, OKX, Bybit, Coinbase). It also clarifies the key differentiator—availability filtered for the caller's connected keys—so an agent can distinguish it from other list-style sibling tools, though it does not name a sibling 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 description clearly implies when to use the tool: when an AI client needs to discover which exchange skills are actually usable with its connected keys. It gives specific context but does not mention alternatives or exclusions, so it stops short of full explicit routing 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?

With no annotations, the description carries the burden of behavioral disclosure. It does explain the selection logic and that it reads from a live table, but it does not mention sorting, default behavior when no exchanges are supplied, or what the returned asset entries contain. This is adequate but not rich.

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

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

The description is compact: two sentences that front-load the purpose and then give parameter guidance. Some parameter text duplicates the schema, but the examples and pair-filtering clarification justify the length.

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 query tool this covers the main purpose and filter semantics, but with no output schema it leaves the return fields vague. It also does not state default scope when no exchange pair is provided or how results are ordered, so an agent would need to infer these details.

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

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

The schema already covers 100% of parameters, so the baseline is 3. The description adds value by clarifying that exchangeA and exchangeB filter pairs between the two exchanges, providing concrete examples ('binance', 'bingx', 0.05), and explaining that minRateDiff uses absolute rate difference in percent.

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

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

The description clearly states the tool returns cross-exchange funding-rate arbitrage opportunities and explains the long/short funding logic. It does not explicitly contrast itself with sibling tools like get_perp_arbitrage or get_spot_arbitrage, so it misses the top score for sibling 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?

The description implies usage: call this when looking for funding-rate arbitrage between two exchanges. However, it provides no explicit guidance on when to prefer this over alternatives such as get_funding_rates or get_perp_arbitrage, and no exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It states what data is returned (current funding rates) but does not disclose whether this is a read-only operation, any rate limits, data freshness, pagination behavior, or how 'current' is defined. The lack of behavioral context beyond the basic return value is a 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 one sentence followed by a compact parameter list. It is front-loaded with the core purpose and avoids excessive detail. The parameter documentation is economical and directly useful.

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 tool with three optional parameters and no output schema, the description covers the parameters and the general return type. However, it omits details like whether the response includes multiple exchanges at once, the structure of the returned rates, and whether results are sorted. These are minor gaps, so a mid-range score is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains that 'asset' is a symbol like 'BTC', 'exchange' is an exchange name like 'binance', and 'limit' has a default of 20 and max of 50. This adds meaning well beyond the bare schema types.

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 current funding rates for perpetual futures across exchanges, with a specific verb ('get') and resource ('funding rates'). However, it doesn't explicitly differentiate from closely related siblings like get_funding_arbitrage or get_funding_schedule, though the 'from all exchanges' scope provides some distinction.

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

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

The description lists the parameters inline, which implies usage context (asset, exchange, limit) but provides no guidance on when to choose this tool over alternatives like get_funding_arbitrage or get_basis_history. There is no exclusion criteria or explicit when-to-use guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals the key output fields, which gives a reasonable picture of what the tool returns, but it does not explicitly state that the operation is read-only, nor does it mention any limitations, timezone assumptions, or error conditions.

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

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

The description is a single concise sentence that front-loads the main purpose and output fields. The trailing 'Params: exchange, symbol' is somewhat redundant with the schema but does not significantly 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 simple two-parameter retrieval tool, the description covers the main purpose and output content, but it lacks details about when to use it vs. related funding tools and does not fully compensate for the absence of annotations and output schema.

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

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

The input schema provides no property descriptions, so the description must add meaning. It clarifies that exchange and symbol identify a perp on an exchange, which is useful context, but it does not specify formats, allowed exchanges, or symbol conventions.

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 a funding schedule for a perpetual contract on a given exchange and enumerates the returned fields: current rate, interval hours, next payment time, and mark price. It is specific enough to be distinguished from siblings like get_funding_rates or get_funding_arbitrage, though it lacks an explicit verb.

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 about when to choose this tool over alternatives such as get_funding_rates or get_funding_arbitrage. The context implies a need for schedule details, but there is no explicit when-to-use or when-not-to-use direction.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It adds useful constraints ('limit max 500', official API, allowed intervals), but does not disclose ordering, default values, return shape, or whether the operation is explicitly read-only.

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

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

A single compact sentence front-loads the resource and then lists every parameter with its relevant constraint. No filler or redundancy.

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

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

For a simple read-only candle retrieval tool, the description covers source, exchanges, symbols, intervals, and limit without an output schema. It could mention the returned candle shape/ordering, but the description is adequate for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it specifies the exchange enum, allowed intervals, and the 500-candle limit. Symbol is named but not elaborated, which is a minor gap since its meaning is self-evident.

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

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

The description names the resource precisely ('OHLCV candles') and the data source ('official exchange API (binance or xt)'), which separates it from sibling quote/orderbook tools. It lacks an explicit verb, but the tool name and noun phrase leave no ambiguity about what is returned.

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

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

The description implies it is for historical/candle data by naming OHLCV candles, and the allowed exchanges and intervals define the scope. It does not explicitly state when to prefer this over sibling market-data tools like get_tickers 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?

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the output nature (headlines with short descriptions) and the limit parameter's default and maximum values, which go beyond the schema. However, it does not mention read-only behavior, output ordering, error handling, or rate limits, leaving some behavioral ambiguity.

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

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

The description is two sentences with no waste: the first sentence states the core purpose and output, and the second provides essential parameter constraints. Information is front-loaded and every sentence earns its place.

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

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

For a simple read-only news tool with one optional parameter and no output schema, the description covers the essential aspects: what is returned, the result format at a high level, and the limit constraint. Missing details such as exact response structure or behavior when limit exceeds the maximum are minor given the tool's low complexity.

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

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

The input schema has 0% description coverage—the only property is a bare 'limit' of type number. The description compensates meaningfully by stating the default (10) and maximum (30), giving agents crucial constraint information. It does not explicitly state that limit is the number of headlines to return, but this is reasonably inferable from context.

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

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

The description clearly identifies the resource as 'latest crypto news headlines with short descriptions,' which is specific enough for an agent to understand what the tool returns. The tool name get_news supplies the verb, and the purpose is distinct from all trading-focused sibling tools, though the description itself does not explicitly state an action verb.

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 when-to-use or alternative tool guidance is provided, but the intended use is strongly implied by the unique news-focused purpose among trading siblings. There is no misleading information, yet there is also no explicit condition directing the agent when to choose this tool over others.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It goes beyond a generic listing by revealing exchange-specific behavior (binance futures, bybit linear perps) and the bingx spot limitation. It does not cover pagination or response format, but the core behavioral traits are present.

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

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

The description is compact and front-loaded; the main action is stated in the first sentence, and the remaining sentences add parameter values, scoping behavior, and an important limitation without redundancy. 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?

Given no annotations, no output schema, and no parameter descriptions in the schema, the description is nearly sufficient for correct selection and invocation. It covers all required invocation details and behavioral nuances, with minor omissions like output shape and authentication expectations.

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

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

Schema description coverage is 0%, and the description fully compensates: it enumerates the valid exchange values, marks symbol as optional, and gives a concrete symbol format example. This adds meaning far beyond the empty schema properties.

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

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

Description opens with the specific verb-resource pair 'List open orders' and immediately scopes it to an exchange, with 'REAL' signaling live versus test environment. The exchange-specific clarifications further distinguish this from sibling tools like get_orderbook, get_positions, and place_order.

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

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

The description gives clear context on when to use this tool: to retrieve open orders, with exchange and optional symbol semantics spelled out. It also provides an explicit negative case, bingx spot returning unsupported, which helps the agent avoid an invalid call, though it does not name alternative sibling tools.

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

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

No annotations are provided, so the description must disclose all behavioral aspects. It mentions the depth default and max, which is useful, but it does not state that the operation is read-only, what the response format is, or any rate-limit or permission considerations.

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 tightly packed sentences with no redundant phrasing. The primary purpose is front-loaded, and the param details are presented efficiently. Every clause adds value.

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

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

While the description covers parameter semantics and basic behavior, it lacks information about the return payload structure (e.g., bid/ask levels, formatting) and potential edge cases. For a simple read tool, this is a moderate gap, not a fatal one.

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

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

Schema description coverage is 0%, so the description must fully compensate. It explicitly defines all three parameters, providing real-world examples for exchange and symbol, and specifies default and maximum values for depth. This adds substantial meaning beyond the bare schema.

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

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

The description clearly states the tool retrieves an orderbook depth snapshot for a given symbol on an exchange. This is specific and distinct from siblings like get_tickers or get_klines, which cover different market data.

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

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

No explicit guidance on when to use this tool versus alternatives. The description gives parameter examples but does not mention suitability conditions or exclusions, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether this is read-only, whether it only returns opportunities without executing trades, or what the response shape contains. The 'get_' name hints at retrieval, but the description itself does not confirm 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 short and front-loads the core concept before listing parameters. Every sentence adds some context, though the second sentence is essentially a bare parameter list rather than meaningful guidance.

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

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

This is a simple getter with no output schema, no annotations, and partial schema coverage. The description does not explain what the response contains, how results are ordered, or any defaults beyond those in the schema. The tool is usable but the description leaves important operational details to be inferred.

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%; limit and minSpreadPct are documented in the schema, but exchangeA and exchangeB have no descriptions. The description merely lists the parameter names and gives the context of two exchanges, without clarifying expected formats, valid values, or the role of each exchange parameter.

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

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

The description defines perp arbitrage as the same perpetual traded on two exchanges with a price spread, which clarifies the resource and intent behind the 'get_' prefix. It is clear enough to distinguish from sibling trading and risk tools, though it lacks an explicit verb like 'fetch' or '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?

There is no guidance on when to use this tool versus alternatives such as get_threat_level, get_tickers, or list_hedge_positions. The description implies it is for screening arbitrage spreads but gives no conditions, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden, and it at least conveys that this reads 'real exchange balances' from connected accounts rather than simulated data. It does not disclose the return shape, whether positions are included, or any auth/account requirements, leaving some behavioral ambiguity.

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

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

The description is compact and front-loads the main purpose before listing supported exchanges and usage guidance. The inline parameter list is a bit dense but carries no redundant 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 low-complexity tool with one optional parameter and no output schema, the description gives the data source, the supported exchanges, and a clear trigger phrase. It could be more complete by specifying whether the tool returns only balances or also positions, but it is sufficient for basic invocation.

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

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

The input schema only declares exchange as a string with no enum or description. The tool description supplies the full semantics: the parameter is optional and limited to one of five specific values. This fully compensates for the 0% schema coverage on the only parameter.

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

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

The description opens with 'real exchange balances from their connected accounts' and names the supported exchanges, which makes the tool's purpose concrete. It stops short of a 5 because it also says to use it for 'positions,' and a sibling tool get_positions exists without any 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?

The description explicitly states when to use it: 'Use when the user asks about their balances, positions, or portfolio.' It does not mention exclusions or compare against alternatives like get_positions, so it earns a 4 rather than 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?

No annotations are provided, so the description must carry the full burden. It mentions the source registry and that it's 'what the agent/bots have open', but it does not explicitly state that this is a read-only operation, nor does it disclose any side effects or behavioral traits. The name 'get' implies read-only, but the description doesn't 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?

Extremely concise, single sentence plus a param listing. Front-loaded with the core purpose and no filler. Every word earns its place.

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

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

For a simple read tool with two optional parameters and no output schema, the description gives the source and scope but lacks details on return structure, pagination, or any filtering nuances. It's minimally complete but doesn't fully guide the agent on expected output.

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

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

Schema coverage is 0%, so the description must explain the parameters. It lists exchange and symbol and marks them as optional, but provides no details on valid values, formats, or how they filter the results. It adds minimal value over the schema, which already lists types.

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 a specific verb (get) and resource (user's open positions from the registry), and adds clarification about agent/bot ownership. However, it does not explicitly differentiate from sibling position tools like list_hedge_positions or get_portfolio, so it's slightly less than excellent.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention when not to use it, nor does it reference any sibling tools for comparison. The agent must infer usage from the name and context.

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

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

There are no annotations, so the description carries the full burden. It describes the strategy being detected, but does not state whether the tool only reports opportunities or can execute trades, nor does it mention order limits, authentication, or result behavior. The words 'buy/sell' could be misread as execution without the qualifier 'opportunities'.

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 compact, front-loaded sentence followed by a parameter list. Every element earns its place and there is no redundant wording or schema repetition.

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

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

With no annotations and no output schema, the description should explain what the tool returns and confirm it is read-only, but it does not. It is enough to identify the tool's purpose but not enough for an agent to fully anticipate behavior and output.

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

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

Because the schema only describes limit and minProfitPct, the description compensates for exchangeA/exchangeB by saying they filter pairs between two exchanges. It also gives a concrete example for minProfitPct (0.5). The main gap is not specifying which exchange is the buy side versus the sell side.

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 ('spot arbitrage opportunities') and explains the strategy ('buy asset on one exchange, sell on another'), which clearly sets it apart from sibling tools like get_perp_arbitrage and get_funding_arbitrage. The tool name and description align on the 'spot' 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?

The description implies the tool is for detecting cross-exchange spot arbitrage, but it never explicitly states when to prefer it over the sibling arbitrage tools (perp, funding) or when not to use it. There is clear context but no exclusions or alternative routing.

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

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

Annotations are absent, so the description carries the burden. It clearly signals a read-only, non-mutating assessment (returns green/yellow/red and reasons) and names the output fields. What it does not disclose: whether the call requires an existing open position, whether it triggers any side effects (e.g., logging or alerts), and what happens if positionId is invalid or stale. That is a meaningful but not critical gap for a read-style 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 sentences, no filler, key output fields and the parameter covered without elaboration. The information-dense format maximizes signal per token for an agent.

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 complete enough for a minimal call when the agent already has a positionId and understands that a threat-level read is non-mutating. Given there is no output schema and no annotations, saying what it does NOT do (no side effects, no guarantee of position existence) and where positionId comes from would tighten the contract. But for the tool's narrow scope, the gap is acceptable.

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

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

Schema coverage is 0%, so the description must explain positionId. It does, albeit briefly: positionId identifies the position whose threat level is assessed. It does not specify the id format (numeric vs. string uuid) or the source from which an agent would obtain it (e.g., from position list vs. close_position response). Still, for a single-parameter tool the description provides the essential semantic tie from the param to the tool's purpose.

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

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

The description states a specific action (get threat level) and resource (a position), and then specifies exactly what output fields the report returns: GREEN/YELLOW/RED, liq distance %, basis deviation %, reasons, recommended action. It names the single required parameter positionId. This disambiguates the tool from siblings like get_agent_events or get_basis_signal 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?

The description implies a use case: when you need a quick risk snapshot of a position. But it does not say explicitly which sibling tools are alternatives, when to use analyze_pair_liquidity or get_basis_regime instead, or any exclusion conditions. Useful but incomplete guidance on selecting it over siblings. With no usage-guidance convention in the schema or annotations unburdening it, a 3 is fair.

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 burden. It adds useful detail about aggregation methodology, exchange coverage, and parameter bounds, but it does not disclose output format, ordering guarantees, or behavior when parameters are invalid or combined.

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

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

Very concise and well-structured. The core purpose is stated first, followed by a compact inline parameter summary. No filler or redundancy.

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

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

For a simple two-parameter tool, the description is mostly sufficient, but there is no output schema and the return structure is not described. An agent would have to infer whether the response is an array of symbols with price fields, which is a meaningful gap given the lack of output schema and annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It does: topN is given a default and max, and symbols is documented with an optional array example. This provides meaningful semantics beyond the bare schema, though it could clarify whether symbols filters or overrides topN.

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

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

The description clearly states the action: returns top crypto prices from an aggregated ticker feed, with global VWAP across 60+ exchanges. This distinguishes it from sibling tools like get_klines or get_orderbook by referencing 'ticker feed' and 'aggregated VWAP'.

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 about when to use this tool versus alternatives. There is no mention of selection criteria, exclusions, or context such as 'use for global market prices' or 'for per-exchange data use get_orderbook'.

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 lists the data fields returned, which gives behavioral context about the output. However, it does not explicitly state that this is a read-only operation (though 'status' implies it), nor does it mention any side effects, error handling, or authorization requirements. The description partially discloses behavior but leaves safety and failure aspects implicit.

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

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

The description is concise – a single sentence listing the returned data, followed by a short parameter note. It is front-loaded with the most important information (what the tool does) and wastes no words. Every sentence earns its place.

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

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

For a simple getter with one optional parameter and no output schema, the description covers the key points: what data is returned, how to scope it with positionId, and the default behavior. It does not address error cases (e.g., invalid positionId) or authentication, but these are likely acceptable gaps given the tool's simplicity.

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

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

The schema has no descriptions (coverage 0%), so the description must compensate. It explains the single parameter well: it is optional, and omitting it returns all open positions. This adds meaningful semantics beyond the bare type definition.

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

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

The description clearly states the verb ('status') and the resource ('hedged position(s)'), and lists specific data points (legs, avg prices, basis, PnL, margin/liq distance, threat level, funding countdown). This distinguishes it from siblings like list_hedge_positions (which likely focus on listing) and get_positions (which may cover all positions, not just hedged ones). The purpose is unambiguous.

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

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

The description gives clear usage guidance for the only parameter: 'positionId (optional — omit for all open positions)'. This tells the agent when to include the parameter and what happens if it's omitted. However, it does not explicitly contrast this tool with alternatives like get_positions or list_hedge_positions, so no exclusions are stated. Still, the context is clear enough for an agent to know when to use it.

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

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

No annotations are provided, so the description carries the full burden. It does not state whether the operation is read-only, safe, or has any side effects. The minimal description assumes safety but does not disclose it.

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

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

The description is a single, focused sentence that immediately states the purpose and lists the output fields. It avoids fluff and is optimally concise with clear structure.

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 identifies the output fields but does not specify the response format (e.g., list of objects), pagination, filtering, or whether all agents are always returned. It is adequate for basic use but leaves room for ambiguity.

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

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

The schema has zero parameters, so parameter description coverage is trivially 100%. The description adds no extra meaning because there are no parameters to elaborate on, resulting in a baseline score of 3.

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

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

The description clearly states the verb 'List' and the resource 'your AI agents', enumerating the returned fields. It is distinct from other agent-related tools but does not explicitly contrast with siblings like get_agent_events or agent_chat, so it misses a perfect 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 provides no guidance on when to use this tool versus alternatives, no conditions or exclusions, and no mention of typical use cases. It simply states what it does without context.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does add the detail that both open and closed positions are returned, which is a behavioral trait beyond the tool name. However, it does not explicitly state that the operation is read-only, nor does it describe the response format or any other characteristics, leaving room for more transparency.

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

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

The description is a single, front-loaded sentence with no filler. It immediately states the core function and the scope (open and closed) in a concise manner. Every word adds value, making it an exemplary structure.

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 list tool with no parameters and no output schema, the description is largely sufficient. It specifies the resource (hedged positions) and scope (user's, open and closed). While it does not outline the return format, this is a minor omission for such a basic operation, and the description covers the essential context an agent needs to decide whether to invoke 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?

The tool has zero parameters, so the schema coverage is clearly 100% and there is no parameter information to add. The baseline for zero parameters is 4, and the description does not need to compensate for any missing parameter documentation. It is entirely satisfactory in this dimension.

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

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

The description clearly states the tool's function: it lists all hedged positions for the user, explicitly including both open and closed. This distinguishes it from sibling tools like get_positions (likely all positions) and close_hedged_position (an action). The phrasing is specific and unambiguous.

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

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

No usage guidance is provided. The description does not mention when to use this tool over alternatives like get_positions or open_hedged_position, nor does it specify any conditions or contrasting scenarios. An agent receives no direction on selecting this tool for a particular need.

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 transparency burden. It discloses that execution is real-mode only, orderbook-driven, limited by max neutral size, sliced, and basis-controlled. It does not cover failure modes or permission requirements, but it reveals the most important behavioral traits for a real-money 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?

The description is compact and front-loaded: the core purpose appears first, followed by execution behavior, the real-mode constraint, and a compact parameter list with inline validations. Every sentence earns its place and no filler is present.

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

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

For a complex 15-parameter real-money tool with no output schema and no annotations, the description covers purpose, execution model, constraints, and most parameters. It does not describe the return value or failure states, but the provided detail is sufficient for an agent to select and invoke the tool with reasonable confidence.

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

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

With only 13% schema description coverage, the description compensates by adding constraints: sizeUsd ≤5000, leverage 1-10, strategy enum values, longExchange default, and a grouped protection parameter list. However, the required 'agent' parameter is absent from the natural-language parameter enumeration, which prevents a 5.

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 action ('Open') and resource ('NEUTRAL hedged position'), clarifies the leg composition (LONG on exchangeA + SHORT on exchangeB, or vice versa), and distinguishes itself from sibling tools like close_hedged_position and adjust_hedge via 'Open' and 'Entry'. This leaves no ambiguity about what the tool does.

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

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

The description gives clear usage context: it opens a neutral hedge, executed by the hedge engine strictly from orderbooks, and explicitly states 'REAL mode only'. It does not name sibling alternatives such as close_hedged_position or adjust_hedge, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden, and it does so well. It states that this is a real (not simulated) order, that SL/TP are placed automatically, that the system may reject oversized orders, and that the mode must be REAL. This is rich, high-stakes 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?

The description is compact and front-loads the core action before constraints. The trailing "Params:" list partially duplicates schema info, but it still adds useful quick-reference value and the overall length is appropriate for a high-stakes execution tool.

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 financially irreversible market-order tool with no output schema, the description is incomplete. It omits the meaning of amount_value, does not mention the required agent parameter, and provides no return or confirmation/error behavior. The risk-limit and auto-SL/TP details are helpful, but critical execution semantics are 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 coverage is only 17%, so the description must explain parameters, but it only lists names and enum values. It fails to clarify what amount_value means for PERCENTAGE vs FIXED_USDT, and it completely omits the required agent parameter. The schema's agent description even mentions bybit, which conflicts with the description's binance/bingx-only claim.

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

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

The description opens with a specific verb and resource: "Place a real market order on the user's exchange." It clearly distinguishes this from sibling tools like close_position, set_sl_tp, or open_hedged_position by emphasizing real execution, market order type, and the connected-exchange constraint.

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

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

The description provides clear operating constraints: trading is only allowed when agent mode is REAL, only connected exchanges are valid, and order sizes are validated against risk limits. It does not explicitly name alternatives or say when not to use this tool in favor of a sibling, so it stops short of a 5.

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

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

No annotations are provided, and the description omits side effects, permissions, irreversibility, or return behavior. As a mutation tool, it should disclose whether thresholds are replaced or merged, and what response the caller can 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 succinct, using two clear sentences. The first lists the affected fields, and the second summarizes the parameters. It avoids unnecessary verbosity while conveying the essential information.

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

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

The description lacks context about the expected output, error handling, or any preconditions (e.g., position must exist and be open). Given the presence of many sibling tools with overlapping functionality, it does not provide enough information to decide when this tool is the best choice versus others like adjust_hedge or set_sl_tp.

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 lists the threshold parameter names, which are somewhat self-explanatory (e.g., slPct suggests stop loss percentage), and clarifies that only positionId is required. However, it does not explain units, allowed ranges, or the meaning of terms like maxBasisDeviationPct or marginAlertPct, so the agent must infer semantics from names alone.

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

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

The description clearly states the tool's purpose: updating protection thresholds of an open position. It enumerates the specific threshold fields (slPct, tpPct, maxBasisDeviationPct, marginAlertPct, autoTopUpUsd), distinguishing it from simpler stop-loss/take-profit tools like set_sl_tp.

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

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

The description notes 'any threshold' implies partial updates, but it does not explicitly indicate when to use this tool versus alternatives such as open_hedged_position, adjust_hedge, or set_sl_tp. It lacks direct guidance on prerequisites or when not to use this tool.

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

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

With no annotations, the description carries the behavioral disclosure burden. It appropriately warns that this is 'REAL' and exchange-side, and it restricts supported exchanges. However, it does not disclose side effects such as overwriting existing SL/TP, what the return value is, or what happens on failure.

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 carry the full purpose, risk qualifier, venue restrictions, and parameter semantics. There is no filler or redundant restatement of the tool name.

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 real-order mutation tool with no annotations and no output schema, the description provides strong parameter and venue context. However, it lacks coverage of important invocation context: what the tool returns, whether it replaces existing SL/TP terms, and failure behavior. This leaves 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 0%, so the description must compensate. It does: all six parameters are named, the pct vs absolute distinction is explained, and the percent-from-entry semantics are provided. It could be more explicit about allowed parameter combinations and units, so a 4 is appropriate.

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

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

The description uses a specific verb ('Set/update') and a concrete resource ('exchange-side stop-loss and take-profit on an open position'). It also flags this as REAL and states supported venues, making it clearly distinguishable from siblings like close_position, place_order, and set_hedge_protection.

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

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

It clearly communicates when to use the tool: to set or update exchange-side SL/TP on an open position. It also gives an exclusion ('bingx spot unsupported'), which helps avoid misuse. It stops short of naming alternative tools or explicit when-not-to-use scenarios, so it is 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, the description carries the full burden. It discloses the external posting action, credential requirement, formatting restrictions, and daily limit. However, it does not mention what the response contains, whether the post is immediately public, or what failure modes may occur (e.g., invalid key).

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

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

Three sentences with no fluff: the purpose comes first, followed by necessary constraints and limits. Every sentence earns its place.

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

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

For a simple two-parameter tool with no output schema or nested objects, the description is largely complete: it covers auth, content formatting, and rate limits. Minor gaps remain around expected response shape and potential errors, but they do not block correct invocation.

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

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

Schema coverage is 100%, so parameter basics are already documented. The description adds valuable content-level constraints beyond the schema: max 3 $TICKER tags and writing prices as plain numbers. This helps the agent construct valid post content.

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

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

The description clearly states the action (Publish a post), the target resource (Binance Square), and the required credential context (Binance Square OpenAPI key). It also includes specific constraints, making it distinct from the trading-oriented sibling tools.

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

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

It provides clear context for when to use the tool: when publishing to Binance Square, with auth prerequisites and daily limits explained. It does not explicitly describe exclusions or alternatives, but no closely comparable sibling exists, so the implicit guidance is sufficient.

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