Gate MCP

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no additional behavioral context (e.g., return format, pagination, or meaning of activity types). It does not contradict the annotations, but it also does not enrich them.

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 words. It is appropriately concise for a zero-parameter tool, though it is under-specified in terms of context.

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

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

With no output schema and zero parameters, the description carries the burden of explaining what the tool returns. It only says 'List activity types' without detailing what an activity type consists of or what the response structure is. An agent would not know what to expect from the output.

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

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

The tool has zero parameters, so the description is not required to explain parameter semantics. A baseline of 4 is appropriate as no parameter documentation is needed.

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

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

The description 'List activity types' clearly states the action (list) and resource (activity types). It distinguishes from sibling tools which list different resources (e.g., currencies, contracts, tickers). However, it does not elaborate on what 'activity types' refers to, leaving some ambiguity for an agent without domain context.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions. The description simply restates the tool's function without saying when it should be selected.

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

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

The description adds no behavioral context beyond what annotations already provide. With readOnlyHint, openWorldHint, idempotentHint, and destructiveHint all present, the agent already knows this is a safe, idempotent read operation. The description merely repeats 'List' without disclosing pagination behavior, default limits, or any other operational traits.

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

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

The description is a single concise sentence that front-loads the purpose. It is not verbose or padded. However, it is extremely bare, leaving out any helpful contextual detail that could have been added without losing conciseness.

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

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

For a simple read-only list tool with optional filters and no output schema, the description is minimally acceptable but relies heavily on the name and schema for completeness. It does not mention the filtering capability (currency) or pagination, which are covered by the schema. The tool is not complex, so this is adequate but not rich.

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 parameters page, limit, and currency are each already documented in the schema. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description 'List Alpha currencies.' uses a specific verb ('List') and clear resource ('Alpha currencies'), distinguishing it from sibling tools like cex_alpha_list_alpha_tickers and cex_alpha_list_alpha_tokens. 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 provides no guidance on when to use this tool compared to alternatives. There is no mention of scenarios where this should be preferred over cex_spot_list_currencies or other list tools, nor any exclusions or prerequisites.

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

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

The annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false) already convey the safety profile. The description adds no additional behavioral context, such as pagination behavior or what 'Alpha' means. It neither contradicts annotations nor provides beyond-annotation value.

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

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

The description is a single short sentence with no waste or redundancy. It is concise but under-specified, omitting important details that could earn their place. Still, it is appropriately front-loaded and not verbose.

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

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

Given the lack of an output schema and minimal description, the agent has no information about the return format or the meaning of 'Alpha' tickers. The tool is very simple, but the description leaves out key context that would help an agent understand what it is listing and what to expect.

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

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

The input schema has 100% description coverage for all three parameters (page, limit, currency), so the description isn't required to explain them. The tool description adds no parameter semantics beyond the schema, which is acceptable per the baseline.

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

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

The description 'List Alpha tickers.' clearly states the verb (List) and resource (Alpha tickers), which is unambiguous. However, it doesn't distinguish this tool from sibling list tools like cex_alpha_list_alpha_currencies or cex_spot_get_spot_tickers, relying instead on the tool name for 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?

No usage guidance is provided. The description does not indicate when to choose this tool over alternatives, nor does it mention any prerequisites or context. It simply states the action without helping the agent decide 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds nothing about pagination, filtering behavior, response format, or other operational traits, thus failing to contribute beyond what annotations and schema provide.

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

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

The description is extremely short but constitutes under-specification rather than efficient concision. It repeats the tool name without elaboration, which does not earn its place. Similar to the calibration example 'Process', the brevity lacks substantive content.

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 optional parameters, no output schema, and two closely related sibling tools (alpha_currencies, alpha_tickers). The description does not explain what 'Alpha tokens' are, what the response includes, or how this tool differs from siblings, leaving substantial gaps for an agent to operate correctly.

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

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

The input schema provides full descriptions (100% coverage) for all 4 parameters: page, chain, address, and launch_platform. The description 'List Alpha tokens' adds no parameter semantics beyond what the schema already contains, so the baseline 3 is appropriate.

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

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

The description 'List Alpha tokens' simply restates the tool name (cex_alpha_list_alpha_tokens) with no additional information. It fails to distinguish the tool from siblings like cex_alpha_list_alpha_currencies or cex_alpha_list_alpha_tickers, making it a tautology with no differentiating value.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention use cases, prerequisites, or exclusions. Given the presence of similar sibling listing tools, the agent is left without context for tool selection.

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

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

The description adds no behavioral context beyond the annotations. Annotations already declare readOnlyHint, idempotentHint, and non-destructive, but the description does not mention expected response structure, whether the contract must exist, or any 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 short sentence, which is concise but essentially restates the tool name. It is not a full tautology because 'dc' is expanded to 'delivery contract', but it provides minimal information and could be considered under-specified.

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

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

With no output schema, the description could have explained the return value or purpose in context (e.g., retrieval of a single contract details). It does not, and it also lacks guidance on how to discover valid contract identifiers, making it incomplete for an agent to fully understand the tool's role.

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 100% description coverage for both parameters, clearly explaining 'contract' and 'settle'. The description adds no extra semantic detail beyond the schema, so it meets the baseline for high schema coverage.

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

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

The description specifies the action 'Get' and the resource 'delivery contract', clearly indicating a single-contract retrieval. It is distinct from sibling list tools like cex_dc_list_dc_contracts, though it does not explicitly state that it returns details for one contract.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention that this is for retrieving a specific delivery contract by ID, nor compare it to list_dc_contracts or other get tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false, covering the safety profile. However, the description adds no behavioral context beyond these annotations, such as return format, pagination, or rate limits, which would be useful given the minimal description.

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, front-loaded and without unnecessary words. However, it is arguably too terse, lacking any elaboration that would improve agent comprehension, though it is not under-specified to the point of being useless.

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 6 parameters, no output schema, and many related sibling tools. The description is too minimal to fully contextualize the tool's role, especially without mention of return values or how it compares to other candlestick tools, making it insufficient for an agent to understand the full scope.

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%, with all six parameters having clear descriptions. The description itself adds no parameter-level detail, so the baseline of 3 applies; the schema carries the burden.

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 'List delivery candlesticks' clearly states the action (list) and resource (delivery candlesticks), identifying the specific market type. It distinguishes from sibling candlestick tools by specifying delivery contracts, though it could be more explicit about the scope and prefix conventions.

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

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

No guidance is provided on when to use this tool versus other candlestick tools like cex_fx_get_fx_candlesticks or cex_options_list_options_candlesticks. The description lacks context on typical use cases, exclusions, or alternative tools.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive, so the safety profile is covered. However, the description adds no behavioral context such as return format, pagination, or whether results are filtered by the optional settle parameter. It provides no info beyond the literal action.

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 clear sentence with no fluff. It's concise and to the point, though it's minimal in detail. It earns its place but doesn't offer any structural enhancements.

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

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

The tool is simple with one optional parameter and no output schema, but the description still feels incomplete. It doesn't explain what a delivery contract is, whether the settle parameter filters results or returns all when omitted, or what the response looks like. Given these gaps, the description is insufficient for full understanding.

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

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

The schema covers the one parameter 'settle' with a clear description, achieving 100% schema description coverage, so the baseline is 3. The description doesn't add extra meaning, but it's not required given the schema is sufficient.

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 'delivery contracts', making it evident what the tool does. It distinguishes from the sibling 'cex_dc_get_dc_contract' through the use of 'list' versus 'get', but it lacks an explicit 'all' or scope indicator, so it's not a full 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 description provides no guidance on when to use this tool versus alternatives. It doesn't mention the optional 'settle' parameter's filtering role or contrast with other list tools (e.g., listing candlesticks or order books).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. However, the description adds no behavioral context beyond what annotations provide—it does not mention pagination, return contents, or any scoping constraints. This is a bare restatement of the tool's name.

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

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

The description is a single short sentence with no filler or redundant words. It is maximally concise, though it leans toward under-specification; however, conciseness is about efficient structure, and this is perfectly economical.

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

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

The tool is simple with only two optional parameters and no output schema, so the description need not be elaborate. However, it does not explain what an 'insurance ledger' contains or clarify the 'delivery' context, which could leave an agent uncertain about the return value. The parameter schema fills some gaps, but the description lacks a complete picture.

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

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

The input schema has 100% coverage: both 'limit' and 'settle' have descriptions, so the schema carries the full burden for parameter semantics. The description itself adds no parameter information, but per the baseline for high schema coverage, a 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 states a specific verb ('List') and a specific resource ('delivery insurance ledger'), which clearly indicates what the tool does. It distinguishes from sibling tools like cex_fx_list_fx_insurance_ledger by the 'delivery' qualifier, though it does not explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives such as the FX insurance ledger or other list tools. The description gives no context about appropriate scenarios, prerequisites, or exclusions, leaving the agent to infer usage purely from the name.

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

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

The description provides no behavioral context beyond what the annotations already declare (read-only, non-destructive, idempotent). It does not mention aggregation behavior, update ID availability, or depth limits, which would be useful for a market data tool.

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

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

The description is a single short sentence with no superfluous content. It is appropriately minimal, though it perhaps under-specifies for a tool with five parameters.

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 five parameters and no output schema, yet the description offers no explanation of return structure, example usage, or relationship to delivery contracts. This leaves significant gaps for an agent attempting 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?

All five parameters have full schema descriptions (100% coverage), so the schema carries the parameter semantics. The description adds no additional parameter context, but the baseline of 3 applies because the schema is sufficient.

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

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

The description uses a specific verb ('Get') and names the resource ('delivery order book'), which differentiates it from sibling order book tools for spot, fx, and options. However, it lacks any additional scoping detail beyond the tool name.

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

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

No guidance is provided on when to use this tool versus the other order book tools (fx, options, spot). The description only states what it does, not when to choose 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. However, the description adds no additional behavioral context—no mention of pagination, default limits, or what constitutes a 'risk limit tier.' It merely restates the listing action, providing no value beyond the annotations.

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

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

The description is a single, short sentence with no unnecessary words or repetition. It is front-loaded with the core verb and resource. While very brief, it is appropriately concise for a simple list operation.

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 four optional parameters and no output schema, the description provides the basic purpose and relies on the schema for parameter details. However, it fails to explain what risk limit tiers are or what the response contains. Given the tool's simplicity and the schema's completeness, the description is minimally viable but lacks deeper context.

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

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

The input schema covers all four parameters (limit, offset, settle, contract) with clear descriptions, achieving 100% schema description coverage. The tool description adds no additional parameter semantics, but the baseline of 3 applies because the schema already handles parameter clarity.

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

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

The description states 'List delivery risk limit tiers,' which uses a specific verb ('List') and a clear resource ('delivery risk limit tiers'). It clearly indicates the tool's function but does not explicitly distinguish itself from sibling list tools or the similar 'cex_fx_get_fx_risk_limit_table' tool.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention filtering, prerequisites, or exclusions. It only restates the core function without any contextual hints 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?

The description adds no behavioral context beyond what the name implies. Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered, but the description does not mention filtering, pagination, or response details. The optional contract parameter's behavior is only documented in the schema, not in the description.

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 zero wasted words. It is appropriately sized for a simple list operation.

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 annotations plus schema provide adequate context. However, the description does not clarify what a 'delivery ticker' is, nor does it mention any output format or filtering behavior beyond the schema parameter notes. Given the low complexity and rich annotations, a minimal description is acceptable, but it remains thinly specified.

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%, with both 'settle' and 'contract' clearly explained. The tool description itself adds no parameter-level detail, so the baseline score of 3 is appropriate when the schema carries the semantic weight.

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 'List delivery tickers' uses a specific verb and resource, clearly distinguishing this tool from siblings like cex_dc_list_dc_contracts and cex_spot_get_spot_tickers. It precisely names the domain (delivery) and the action (list tickers).

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 alternative ticker-listing tools, nor does it mention any exclusions or prerequisites. It only states the basic function.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context, such as pagination via last_id or rate-limit concerns. It does not contradict the annotations, and the read-only nature is consistent with 'List'.

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

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

The description is a single sentence, perfectly front-loaded with the action and resource, and contains no unnecessary words or filler. It is as concise as a description can be while still conveying the core purpose.

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

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

Despite having annotations and a well-documented schema, the description is too minimal to provide complete context for a tool with 6 parameters and optional filters. It does not explain what a 'delivery trade' is, how the required 'contract' parameter relates to the listing, or what kind of data is returned. The lack of an output schema further amplifies this gap.

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

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

Schema description coverage is 100%, so all six parameters (to, from, limit, settle, last_id, contract) are already documented with meaningful descriptions. The tool description itself adds no parameter-specific information, so it does not go beyond what the schema provides, yielding 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 'List delivery trades' clearly states the action (list) and the resource (delivery trades), with 'delivery' distinguishing it from other trade-listing tools like spot, Fx, and options trades in the sibling list. This is a specific verb+resource pairing that 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 provides no guidance on when to use this tool versus alternatives. It does not mention why an agent would choose this over other trade listing tools, nor does it state any prerequisites or exclusions. The only context is the word 'delivery', which implies but does not explicitly explain the appropriate use case.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds no extra behavioral context beyond that (e.g., auth requirements, pagination behavior, response size). No contradiction, but also zero added value.

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

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

The description is a single short sentence, but it is essentially a tautology of the tool name. It wastes the opportunity to provide useful navigation or caveats, so it is under-specified rather than appropriately concise.

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

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

Given there is no output schema, 7 optional parameters, and no usage guidance, the description is far from complete. An agent has no idea what a 'dual investment plan' is, what parameters to combine, or what results to expect.

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

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

Schema covers 100% of parameters with meaningful descriptions. The description itself adds no parameter semantics, but baseline is 3 because the schema already does the heavy lifting.

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

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

Description states verb 'List' and resource 'dual investment plans', which is specific and matches the tool name. However, it doesn't distinguish from sibling earn tools like cex_earn_list_earn_fixed_term_products or cex_earn_list_uni_currencies, so an agent might not know which is which.

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

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

Provides no guidance on when to use this tool vs alternatives. No context, prerequisites, or comparison to sibling list tools. The description is merely a restatement of the tool name.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context beyond the basic operation (listing). It is consistent with the annotations but does not disclose additional traits such as pagination defaults or response structure.

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 clear sentence, front-loaded with the action and object. There is zero waste; 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 list tool, the description is adequate, but it lacks mention of the sibling 'by_asset' variant for filtered queries and does not describe the return format or pagination behavior. While annotations and schema are strong, the absence of these contextual details leaves some gaps.

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

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

Schema coverage is 100%, so all four parameters have descriptions (page, limit, type, asset). The tool description itself adds no parameter-level meaning. Thus the baseline of 3 applies, as the schema already carries the semantic burden.

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

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

The description uses a specific verb and resource: 'List fixed-term Earn products.' It clearly states what the tool does, and the name further clarifies the scope. However, it does not explicitly distinguish itself from the sibling 'cex_earn_list_earn_fixed_term_products_by_asset', which is a related but asset-filtered variant.

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

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

The description implies usage: when you need to list fixed-term Earn products. But it provides no explicit context about when to prefer this over the asset-specific sibling, nor does it mention any exclusions or prerequisites. This is minimal implied guidance, not a clear comparison to alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context (e.g., pagination, return format, or sub-behaviors) beyond what annotations provide, so it meets the baseline but does not exceed 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, clear, front-loaded sentence with no filler. It conveys the essential purpose efficiently and 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 list tool with comprehensive annotations and full schema coverage, the description is sufficient. It lacks an explicit note about the unfiltered sibling, but the core purpose and safety profile are clear. No output schema exists, so return-value complexity is not a factor.

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

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

The input schema has 100% description coverage: 'asset' is explained with examples (USDT, BTC), and 'type' is detailed as 'empty or 1=normal, 2=vip, 0=all'. The tool description itself adds no additional parameter meaning, so with full schema coverage the baseline of 3 is appropriate.

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

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

The description 'List fixed-term Earn products by asset' uses a specific verb ('list'), identifies the resource ('fixed-term Earn products'), and adds a clear scope ('by asset'). This distinguishes it from the sibling tool `cex_earn_list_earn_fixed_term_products` which does not include 'by asset'.

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 should be used when you need fixed-term Earn products filtered by a specific asset, but it does not explicitly state when to use this versus the unfiltered sibling. No alternatives or exclusions are mentioned, so guidance remains implicit rather than explicit.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, which aligns with the 'list' operation. The description adds no additional behavioral context, but for a simple list operation this is adequate and shows no contradictions.

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

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

The description is an extremely concise single sentence ('List Simple Earn currencies.') with no unnecessary words or repetition. It is perfectly sized for a trivial list operation.

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

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

For a simple no-parameter list tool with good annotations, the description is adequate. It could optionally clarify what 'Simple Earn currencies' entails or describe the return format, but given the low complexity and annotations, it is sufficiently complete.

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

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

The tool has zero parameters, so the description does not need to explain parameter semantics. The baseline score of 4 applies since there are no parameters to document.

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

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

The description clearly states the tool lists Simple Earn currencies using the specific verb 'list' and the resource 'Simple Earn currencies'. This distinguishes it from sibling tools that list other currency types, such as cex_spot_list_currencies or cex_alpha_list_alpha_currencies.

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 explicit guidance on when to use this tool versus alternatives. It merely states the capability without indicating context, prerequisites, or exclusions. Usage is only implied by the tool's name and description.

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

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

The description adds no behavioral information beyond what the annotations already provide (readOnlyHint, idempotentHint, etc.). It does not mention pagination, response format, timezone defaults, or other nuances. The annotations cover the safety profile, so this is not a contradiction, but the description is silent on additional 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 a single, concise sentence that directly states the tool's purpose without extraneous information. It is front-loaded and easy to parse, making it highly efficient.

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

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

For a simple data retrieval tool with strong annotations and a fully documented schema, the description is minimally adequate. However, there is no output schema and the description does not hint at the response structure beyond 'OHLCV', which could be considered a gap. Still, the tool is straightforward and the purpose is clear enough for selection.

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

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

The input schema has 100% description coverage for all 7 parameters, so the baseline is 3. The description itself adds no parameter-level details; the schema is the primary source. This meets the baseline but does not exceed it.

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

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

The description clearly states the action ('Get') and the resource ('futures candlestick/OHLCV data'), which distinguishes it from other candlestick tools for spot, options, and DC markets. The verb is specific and the scope 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 implies the tool should be used for futures candlestick data, but it does not explicitly mention when to use it versus alternatives like spot or options candlesticks. No exclusions or alternative tool references are provided.

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

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

Annotations already declare this as read-only (readOnlyHint=true) and idempotent (idempotentHint=true). The description adds no additional behavioral context such as rate limits, pagination, or what 'details' includes. It simply restates the function without enriching the safety profile already covered by annotations.

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

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

The description is a single concise sentence, front-loaded with the action ('Get') and resource ('details of a single futures contract'). Every word earns its place, with 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 getter with strong annotations and full schema coverage, the description is minimally adequate for tool selection. However, it lacks information about the return payload (no output schema) and any special behavior, leaving some ambiguity about what 'details' entails. It is complete enough for selection but not fully self-contained.

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

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

The input schema provides descriptions for both parameters ('contract' and 'settle'), covering 100% of parameters. The tool description does not add any parameter-level semantics, so a baseline score of 3 is appropriate per the rubric when schema coverage is high.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('details of a single futures contract'), distinguishing it from list operations like cex_fx_list_fx_contracts. The word 'single' clarifies that this is for one contract, not a list.

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

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

The description does not explicitly state when to use this tool versus alternatives like cex_fx_list_fx_contracts, though 'single' implies it is for retrieving a specific contract. No exclusions or alternative guidance is provided, leaving the usage context implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds minimal behavioral context beyond 'history' implying a time-series, but omits details like pagination, default time ranges, or response format. No contradictions with annotations.

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

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

The description is a single sentence, front-loaded with the verb and resource, with zero filler. Every word contributes to the meaning, making it highly 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 simple read-only data query with comprehensive schema coverage, the description adequately states the purpose and scope, but it doesn't mention return format, default behavior, or alternatives. It is the minimum viable for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100% for all five parameters, so the schema already fully explains each parameter. The description adds no extra semantic meaning beyond what the schema provides, maintaining the baseline score.

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

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

The description clearly identifies the resource ('funding rate history') and action ('Get'), and scopes it to 'a futures contract', which distinguishes it from sibling tools like get_fx_tickers or get_fx_premium_index. It 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 guidance is provided about when to use this tool versus alternatives like list_batch_fx_funding_rates or get_fx_premium_index. It lacks context about use cases, 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context such as rate limits or pagination. It is consistent with annotations but provides no additional value beyond them.

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 directly states the tool's function without any 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?

The tool is straightforward, and the schema comprehensively documents parameters. Annotations cover safety. The absence of an output schema is mitigated by the standard concept of an order book. However, a brief note about return structure could marginally improve completeness, but it's adequate 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?

Input schema covers 100% of parameters with descriptions, so the schema does the heavy lifting. The description adds no further parameter semantics, matching the baseline for full schema coverage.

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

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

The description 'Get futures order book' clearly states the action (get) and resource (futures order book), distinguishing it from spot and options order book siblings. It is specific but not exhaustive, as it doesn't explicitly mention 'FX' despite the tool name containing fx.

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

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

No guidance is provided on when to use this tool versus alternative order book tools for spot, options, or DC contracts. The description merely states what it does without indicating context 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the definition of premium index, which is helpful context, but does not disclose additional behavioral traits such as pagination, rate limits, or data ordering. Thus, it adds some value beyond annotations but not extensive.

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 that directly explains the tool's function without redundancy. It earns its place by adding the premium index definition, which is essential for understanding.

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 read-only nature, clear purpose, and full schema coverage, the description adequately supports agent selection and invocation. The term 'history' implies a time-series return, and the schema covers the time parameters, making the combination sufficient. No output schema exists, but the simple concept does not require further explanation.

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 descriptions for all six parameters, achieving 100% coverage. The description itself only highlights the required 'contract' parameter and does not add syntax, format, or default behavior details beyond the schema. Therefore, it meets the baseline but does not go beyond it.

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

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

The description clearly states the action ('Get'), the specific resource ('premium index history'), and the target ('for a contract'). It further defines premium index as 'mark price minus index price', which distinguishes this from sibling tools like funding rate or candlesticks. This 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?

The description implies usage for retrieving premium index history but does not explicitly explain when to use this tool over alternatives or mention any exclusions. While the context is clear, there is no comparison to sibling tools like funding rate or candlestick endpoints, so usage guidance is minimal.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds no additional behavioral context (e.g., auth, rate limits, side effects) but is consistent with the annotations.

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

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

A single, direct sentence that immediately communicates the tool's purpose. No filler or redundant information—ideal conciseness.

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

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

Given the simplicity of the operation, the existing annotations, and fully documented parameters, the description is complete enough for an agent to select and invoke the tool correctly. A minor improvement could be mentioning the return payload, but it's not necessary given the clear scope.

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

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

The input schema already provides 100% coverage with descriptions for both parameters (settle and table_id). The description does not add further semantic detail beyond what the schema documents, so baseline 3 applies.

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

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

The description clearly states the action ('Get'), the resource ('risk limit tier table'), and the identifier ('by table ID'). It distinguishes itself from sibling tools that list contracts or get other resources.

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 usage context is clear: this is for fetching a single specific table by ID. No exclusions or alternatives are mentioned, but given the tool's specificity and the absence of a sibling list tool for fx risk limit tables, the context is sufficiently evident.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds no extra behavioral context, such as pagination, return format, or whether 'ticker information' includes specific fields. Since annotations cover the key traits, a baseline 3 is appropriate, but the description does not disclose anything beyond the annotations.

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

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

The description is a single, concise sentence with no extraneous words. It is front-loaded with the action ('Get') and resource ('ticker information'), making it immediately clear. There is no waste, and it is appropriately sized for a simple 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 simple read-only market data tool with rich annotations and full schema coverage, the description is largely sufficient. It clearly states what the tool returns ('ticker information for futures contracts'). Minor gaps: it does not mention that the tool supports filtering by contract via the 'contract' parameter, and it omits the 'FX' qualifier, which could cause confusion with other futures products. However, these are not critical given the schema and tool name.

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

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

The input schema provides full descriptions for both parameters ('Settlement currency' and 'Futures contract name' with note about filtering). Schema description coverage is 100%, so the description does not need to compensate. The tool description itself adds no parameter semantics, but the schema does the heavy lifting, warranting the baseline of 3.

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

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

The description clearly states a specific verb+resource: 'Get ticker information for futures contracts.' It distinguishes this as a ticker endpoint, but it does not explicitly mention that this is for FX futures, which is a slight gap given the tool name includes 'fx'. Sibling tools like cex_fx_get_fx_contract and cex_spot_get_spot_tickers exist, so the description could have been more precise about the asset class.

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 specify that this is the appropriate tool for FX futures tickers, nor does it mention any exclusions or fallback tools. The sibling list contains many similar market data tools (candlesticks, funding rates, order books), but the description does not help disambiguate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds the 'recent public' qualifier, indicating data scope, but does not disclose behaviors like pagination defaults or rate limits. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a simple data retrieval tool and every word contributes to the purpose.

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

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

The tool is simple, annotations cover safety, and the schema fully documents parameters. The description lacks some contextual details like explicit mention of FX futures, but the name and schema compensate. No output schema means return values need not be described.

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 descriptions for all 7 parameters (100% coverage). The description itself adds no additional parameter-level semantics, so it meets the baseline for full schema coverage.

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

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

The description clearly states a specific action ('Get recent public trades') and a specific resource ('futures contract'). It distinguishes itself from sibling trade tools by implying the futures market, though it does not explicitly name FX. The tool name reinforces this context.

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

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

No guidance is provided on when to use this tool versus alternatives like cex_spot_get_spot_trades or cex_options_list_options_trades. There are no usage context hints, exclusions, or alternative mentions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds that the tool returns 'constituent assets and weights,' which is useful but does not go beyond what the purpose already conveys. No additional behavioral traits like pagination, defaults, or error cases are disclosed.

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

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

The description is a single, direct sentence that front-loads the verb and resource. No wasted words; perfectly concise and scannable.

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

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

For a simple getter with only two parameters, strong annotations (read-only, idempotent), and a clear return concept ('assets and weights'), the description is complete enough. No output schema exists, but the description explicitly states what data will be returned, so the agent has sufficient context to invoke the tool correctly.

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

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

Schema description coverage is 100%: both 'index' and 'settle' have descriptions. The tool description adds minimal extra meaning beyond the schema, such as the 'futures' context. With full schema coverage, the baseline of 3 applies; no additional parameter details are provided.

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

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

The description states exactly what the tool does with a specific verb and resource: 'Get constituent assets and weights for a futures index.' This clearly distinguishes it from sibling tools like cex_fx_get_fx_order_book or cex_fx_list_fx_contracts, which are about different data. No ambiguity.

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 its usage context by naming the resource (index constituents), but it does not explicitly state when to use this tool versus alternatives or when not to use it. With many fx getters/listers among siblings, explicit guidance would help, but the resource name alone makes the primary use case obvious.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds 'current' and 'multiple contracts' but provides no additional behavioral details such as response format, pagination, or rate limits. This aligns with the baseline for annotation-covered read tools.

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 zero filler. Every word contributes to clarifying the tool's purpose and scope.

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 batch tool with strong annotations and full schema coverage, the description is sufficient. It clearly states what the tool does. The only minor gap is not mentioning response format or the optional 'settle' parameter's role, but the schema covers the latter and the tool is low-complexity.

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

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

Schema description coverage is 100%, as both parameters have detailed descriptions (e.g., contracts format includes an example). The description itself does not add extra meaning beyond restating the batch nature, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('current funding rates') with a clear scope ('multiple contracts in one request'). It directly distinguishes itself from the sibling tool cex_fx_get_fx_funding_rate, which handles single contracts.

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 'in one request' clearly implies batch usage, setting context for when to use this tool. However, it does not explicitly name the alternative for single-contract requests or provide exclusion criteria, stopping 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?

Annotations already declare the tool as read-only, non-destructive, idempotent, and open-world, so the safety profile is well established. The description adds examples of the statistics returned but does not disclose behaviors like pagination, rate limits, or response format, which is acceptable given the annotations.

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

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

The description is a single sentence with no wasted words, front-loaded with the core purpose and enriched by concrete examples. It is appropriately concise for a simple data retrieval 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 straightforward read-only list operation with comprehensive parameter descriptions and strong annotations, the description is adequate. The 'etc.' is vague, but the combination of schema and name implies a time-series list of stats, making the overall context reasonably complete.

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

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

Schema coverage is 100% (all five parameters have descriptions in the schema), so the description does not need to explain parameters. It adds no additional parameter semantics beyond what the schema already provides, hence the baseline score.

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

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

The description uses a specific verb ('Get') and resource ('contract statistics') with concrete examples ('open interest, long/short ratio'), clearly distinguishing it from sibling tools like cex_fx_get_fx_tickers or cex_fx_get_fx_contract.

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, no mention of exclusions or prerequisites. The description simply states what the tool does without any selection criteria.

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

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

With annotations already declaring readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, the description need not restate safety traits. It does add the resource scope ('perpetual futures contracts') but fails to disclose that 'all' is subject to pagination via limit/offset, which could mislead an agent expecting a single complete list.

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 short sentence containing exactly the essential information: verb, resource, and scope. Zero fluff, appropriately front-loaded, and 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-only list tool with comprehensive schema coverage and strong annotations, the description is mostly complete. However, the gap between 'all' and the pagination parameters, plus the lack of an output schema, leaves minor room for ambiguity about return structure and pagination behavior, so it is not a perfect 5.

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

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

The input schema provides descriptions for all three parameters (limit, offset, settle) with 100% coverage, so the description carries no parameter-specific information. Baseline 3 is appropriate because the schema already does the heavy lifting for parameter understanding.

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

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

The description uses the specific verb 'List' with a clear resource ('perpetual futures contracts'), which directly matches the tool name and distinguishes it from the singular get_fx_contract sibling. The scope ('all') is stated, making the tool's purpose unambiguous.

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

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

The description clearly implies this tool is for enumerating FX perpetual futures contracts, which is sufficient context for a simple list operation. However, it does not explicitly exclude alternatives or mention when to prefer this over related list tools like cex_fx_list_contract_stats, so it lacks explicit when-not guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context (e.g., pagination, data structure) but also does not contradict annotations.

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

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

One concise sentence with no filler or redundancy. It is appropriately front-loaded and 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?

With no output schema and two optional parameters, the description offers minimal context about the response or usage details. It is essentially a restatement of the tool name and lacks additional helpful context beyond the 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 already provides descriptions for both parameters ('limit' and 'settle') at 100% coverage. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description clearly uses 'Get' with a specific resource ('futures insurance fund history'), so it states the tool's core function. However, it does not differentiate from similar sibling tools like cex_dc_list_dc_insurance_ledger, though the 'futures' context is reasonably distinctive.

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 information is provided about when to use this tool versus alternatives, nor any exclusions. The description simply states what it does without contextual 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'personal' scope, implying user-specific data, but does not disclose return format, pagination behavior, or any other behavioral traits beyond the annotated hints.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the exact purpose efficiently and earns its place with no redundant wording.

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 strong annotation profile and complete parameter descriptions, this read-only list tool is adequately specified. The term 'liquidation history' implies a list of past liquidation events, which is sufficient for an agent to understand the tool's output, even without an output schema. However, it could benefit from a note about response structure or pagination defaults.

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

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

All 5 parameters are fully described in the input schema, so the description adds no additional semantic value. The baseline of 3 is appropriate since the schema handles parameter meaning entirely.

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 'Get personal futures liquidation history' uses a specific verb and resource, clearly distinguishing it from sibling market-data tools like cex_fx_list_fx_contracts or cex_fx_list_contract_stats. The word 'personal' clarifies it is account-specific data, but it does not explicitly differentiate from all possible alternatives.

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

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

Usage context is only implied: you would use this tool when you need your own futures liquidation history. There is no explicit mention of when not to use it, alternatives, or prerequisites such as authentication or position requirements.

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

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

The description adds 'public, no auth' which is critical behavioral context not covered by the annotations. Combined with the readOnlyHint and idempotentHint annotations, the agent is fully aware this is a safe public read operation with no 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 a single, front-loaded sentence with zero wasted words. It states the action, resource, and key usage context (public, no auth) efficiently.

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

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

For a simple list tool with a well-documented schema and safety annotations, the description is adequate. It includes the essential context (auth requirements) but could theoretically mention pagination or return value shape; however, the schema already specifies limit/offset and the tool name implies a list return.

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

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

All 6 parameters are described in the schema with 100% coverage, so the description does not need to repeat them. The phrase 'with optional filters' merely reinforces that parameters are optional, adding no new meaning. Baseline score for full schema coverage is 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 'List CandyDrop activities' with a specific action (List) and resource (CandyDrop activities). It distinguishes itself from sibling tools by focusing on activities rather than rules, for example 'cex_launch_get_candy_drop_activity_rules_v4'.

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 '(public, no auth)' which explicitly communicates that this endpoint requires no authentication, providing clear context for when to use it. It does not mention alternatives or exclusions, but the uniqueness of the resource is sufficient.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful context by stating it is public and that the response includes prize pools and tasks, which goes beyond the structured annotations and informs the agent about response content and accessibility.

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

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

The description is a single sentence that efficiently packs the tool's purpose, the key resource, and the parameter requirement. There is no filler, repetition, or unnecessary detail, making it exceptionally 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 simple read-only tool with only two parameters and no output schema, the description adequately covers what the tool does, what it returns, and the key invocation constraint. It could potentially detail the return structure more, but the low complexity and strong annotations make this sufficient.

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

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

The input schema has 100% description coverage for both parameters. The description adds the crucial OR relationship and the fact that at least one is required, which is not explicitly stated in the individual parameter descriptions. This additional constraint is valuable for correct invocation.

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

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

The description uses a specific verb 'Get' and resource 'CandyDrop activity rules' with content details (prize pools and tasks), clearly distinguishing it from the sibling tool 'cex_launch_get_candy_drop_activity_list_v4' which lists activities. It 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?

The description explicitly states the calling convention: 'Pass activity_id OR currency (at least one required by API)'. This provides clear context for parameter usage. However, it does not explicitly mention when to use this tool instead of the sibling activity list tool, so it stops short of full 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context about authentication: 'public; logged-in users may see extra participation info', which is a behavioral nuance not present in annotations. It does not contradict any annotations and adds meaningful detail beyond metadata.

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

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

The description is a single sentence, concise, and front-loaded with the main verb and resource. Every word adds value: the resource, the optional filters, and the authentication nuance. No filler or repetition of schema details.

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

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

Given the tool's low complexity (5 optional params, no output schema) and rich annotations, the description adequately covers the core purpose and auth-dependent behavior. It does not describe the return format, but for a list tool without an output schema, this is less critical. The description is sufficient for an agent to select and invoke it correctly, especially with sibling differentiation via the resource name.

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

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

Schema description coverage is 100%, so all five parameters have descriptions in the schema itself. The description merely mentions 'optional filters' without elaborating, which is redundant with the schema. Baseline 3 is appropriate because the schema does the heavy lifting and the description adds no additional parameter semantics.

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

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

The description uses a specific verb 'List' and a clear resource 'HODLer Airdrop campaigns', making the tool's purpose unambiguous. It also mentions optional filters, which aligns with the input schema. The name itself distinguishes this from sibling tools like candy drop or launch pool lists, providing strong 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 does not explicitly name alternative tools, but the resource type (HODLer Airdrop campaigns) clearly separates it from key siblings such as cex_launch_get_candy_drop_activity_list_v4 and cex_launch_list_launch_pool_projects. It provides context that the tool is public but logged-in users may see extra participation info, which helps decide when to use it. However, it lacks explicit exclusion statements like 'use X instead for Y'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description's 'List' is consistent with these. However, it adds no extra behavioral context beyond the annotation-covered facts, such as pagination behavior or response characteristics.

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 efficiently conveys the core action. It is not over-verbose, but it lacks any structured additions like examples or notes that could enhance usability without being wasteful.

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

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

With no output schema and no explanation of what launch pool projects are or what the response contains, the description is incomplete. The tool has 7 filters, indicating complexity, but the description does not fill the information gap left by the missing output schema, leaving the agent uncertain about the return value.

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

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

Schema description coverage is 100%, so all seven parameters have descriptions in the schema. The description adds nothing beyond 'optional filters' to parameter meaning. Baseline for high coverage is 3, and no extra contextual value is provided.

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

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

The description 'List launch pool projects with optional filters' clearly identifies the action (list) and resource (launch pool projects). It is specific enough to understand the tool's basic function, though it does not explicitly differentiate from sibling launch-related tools like cex_launch_get_candy_drop_activity_list_v4 or cex_launch_get_hodler_airdrop_project_list.

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

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

The description provides no guidance on when to use this tool vs alternatives. It mentions 'optional filters' but does not explain context, prerequisites, or exclusionary cases. There is no mention of other sibling tools or scenarios where this tool is preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety profile. The description adds no behavioral detail beyond the word 'Get', so it neither enhances nor contradicts the annotations.

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

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

A single, well-formed sentence with no filler or redundant information. Every word contributes to stating the tool's function.

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, one-parameter tool with rich annotations, the description is nearly sufficient. It does not explain the return format or the exact meaning of 'margin leverage tiers', but the absence of an output schema and the simplicity of the operation keep the gap small. A 4 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?

The schema provides 100% coverage for the single parameter, including an example (BTC_USDT). The description's phrase 'for a currency pair' only restates the schema field, adding no additional semantic value beyond what is already documented.

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 'Get margin leverage tiers for a currency pair' clearly identifies the action (get), the resource (margin leverage tiers), and the scope (currency pair). It is specific and distinguishable from sibling tools like cex_margin_get_uni_currency_pair or spot/list tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention related tools, when not to use it, or any distinguishing context beyond the basic purpose.

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

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

The description is consistent with annotations (readOnlyHint=true, destructiveHint=false) but adds no extra behavioral context such as rate limits, required permissions, or return behavior. With annotations already covering safety, the description contributes little beyond the basic 'get' semantics.

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, clear sentence that is front-loaded with the verb and object. No unnecessary words or repetition.

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

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

For a simple read-only retrieval tool with one fully documented parameter and a clear sibling list tool, the description is adequate. However, since there is no output schema, the description could have briefly mentioned what 'details' are included (e.g., margin tier, status), but this is a minor gap.

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

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

Schema coverage is 100%, with the single parameter well-described by 'Currency pair, e.g. ADA_USDT'. The description itself adds no additional parameter insight, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get details') and identifies the exact resource ('specific unified margin currency pair'), clearly distinguishing it from the sibling list tool (cex_margin_list_uni_currency_pairs). The word 'specific' signals this is a single-pair retrieval operation.

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 no explicit guidance on when to use this tool versus alternatives like cex_margin_list_uni_currency_pairs. The word 'specific' implies a single pair, but there is no mention of exclusions, prerequisites, or scenarios where other tools would be more appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is fully covered. The description adds no further behavioral traits such as pagination, ordering, or rate limits, but it is consistent with the read-only nature and adds the 'unified margin lending' context.

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

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

A single sentence of eight words that immediately conveys the action and scope with no filler or redundant phrasing. The description is front-loaded with the verb and resource, making it optimally concise.

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

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

For a parameterless list endpoint with strong annotations, this description is sufficient. It states exactly what is listed (all currency pairs for unified margin lending) and the return type is inferable from the 'List' verb. No output schema exists, but none is needed for such a simple tool.

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

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

The tool has zero parameters, and the schema is trivially complete at 100% coverage. No parameter explanation is needed, so the baseline of 4 applies as per the rubric for parameterless tools.

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

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

The description uses the imperative 'List' with a specific resource 'all currency pairs supported for unified margin lending', clearly distinguishing it from sibling tools like cex_margin_get_uni_currency_pair which retrieves a single pair. The verb and resource are precise, leaving no ambiguity about the tool's function.

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

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

The description provides clear context that this tool is for listing all unified margin currency pairs, which implicitly tells when to use it versus spot or earn listing tools. However, it does not explicitly state alternatives or exclusion criteria, so it stops short of a perfect score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'public' qualifier, which is useful context, but it does not describe return format, rate semantics (e.g., borrowing vs lending rate), or any limitations. With annotations present, the added value is moderate, so a baseline 3 is appropriate.

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 short, front-loaded sentence that conveys the action, target, and access level with zero waste. It is appropriately sized for a low-complexity public getter.

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

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

For a simple read-only tool with complete schema descriptions and good annotations, the description is sufficiently complete. It explains the core purpose and scope, though it leaves the exact meaning of 'interest rates' slightly ambiguous (e.g., borrow vs. lend). Given the low complexity and no output schema, a 4 is warranted rather than 5.

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

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

Schema description coverage is 100%, with both vip_level and currencies described succinctly. The description adds no additional parameter semantics beyond the schema, so the baseline 3 is correct. The tool-level description does not need to repeat what the schema already covers.

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

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

The description clearly states 'Get current interest rates for specified currencies in multi-collateral loans'. The verb is specific, the resource is precise, and the qualifier 'current' distinguishes it from the sibling tool cex_mcl_get_multi_collateral_fix_rate. The word 'public' further clarifies access scope.

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

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

The description implies when to use it: when you need current rates for specific currencies. However, it does not explicitly mention alternatives such as the fixed-rate tool or the LTV tool, nor does it state when not to use it. No explicit exclusions are provided, so usage timing is inferred rather than explicit.

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

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

Annotations already declare read-only, idempotent, and non-destructive hints. The description adds value by noting '(public)', clarifying that the endpoint requires no authentication. It does not describe return structure or pagination, but given the annotations, the behavioral disclosure is adequate.

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

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

The description is a single, front-loaded sentence with no redundant information. Every word serves a purpose, and the parenthetical '(public)' adds essential context 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's low complexity (no parameters, simple read operation) and the presence of comprehensive annotations, the description is sufficient. It clearly states what the tool returns (fixed rates) and the public nature, though it stops short of describing the exact response format. For such a simple tool, this level of detail is complete enough.

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 per the baseline, a score of 4 is appropriate. The description correctly focuses on the output concept (fixed interest rates) without needing to explain parameter details.

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 ('available fixed interest rates for multi-collateral loans') and adds scope ('public'). It distinguishes this tool from similar siblings like 'cex_mcl_get_multi_collateral_current_rate' by specifying 'fixed' rates, making the purpose unambiguous.

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

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

The description implies usage for retrieving fixed rates but provides no explicit when-to-use or exclusion guidance. It does not mention the alternative 'current_rate' tool, leaving the agent to infer the distinction. For a zero-parameter public endpoint, this is acceptable but not exemplary.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds the 'public' accessibility context, which is useful but not extensive. No contradiction with annotations.

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

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

The description is a single, compact sentence that contains no filler and immediately conveys the tool's function.

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

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

For a zero-parameter public read with strong annotations, the description fully states what is returned (LTV ratios) and the domain (multi-collateral loans). No output schema exists, but the resource is clear enough.

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

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

The input schema has zero parameters, and the description adds no parameter-level details. This is acceptable because there is nothing to document; a baseline of 4 applies for parameterless tools.

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

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

The description clearly identifies the operation: retrieving LTV ratios for multi-collateral loans. The noun 'LTV' differentiates it from sibling tools like current_rate and fix_rate, making the purpose unambiguous.

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

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

The description implies the tool is for public retrieval of LTV ratios and marks it as 'public', indicating no authentication is needed. It does not explicitly name alternatives, but the purpose is self-evident and distinct from sibling tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds the useful note that this is a 'public' endpoint, implying no authentication is required, which enriches the behavioral profile beyond the annotations.

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

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

The description is a single, front-loaded sentence with no redundancy. Every word contributes meaning: verb, resource, scope, and public access.

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

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

For a simple, parameterless list tool with robust annotations, the description provides sufficient information: it states what is returned (list of supported currencies) and that it is public. No output schema exists, but the action is straightforward and well-defined.

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 fully covers the input space (vacuously). No additional parameter description is needed, earning the baseline 4 for zero-parameter tools.

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

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

The description uses a specific verb 'List' and names the exact resource 'supported currencies for multi-collateral loans', making the tool's purpose unambiguous. It distinguishes itself from sibling currency listers by explicitly scoping to the MCL 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 context is clear: use this tool to get all currencies eligible for multi-collateral loans. It doesn't explicitly mention alternatives or when-not-to-use, but the product-specific scope provides sufficient 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?

Annotations already declare the tool to be read-only, open-world, idempotent, and non-destructive. The description adds no further behavioral context, but it also does not contradict the annotations. For a simple get operation, this is adequate, though it could mention response format or error behavior.

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

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

The description is a single, focused sentence with no filler words. It is front-loaded with the action and resource, making it instantly scannable and appropriately sized for the tool's simplicity.

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

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

Given the tool's simplicity and the presence of safety annotations, the description is minimally viable. However, no output schema exists, and the term 'details' is vague—it does not clarify what information will be returned or what 'single' means in terms of identifying the contract. A slightly richer description would improve completeness.

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

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

The schema covers the single parameter 'contract' with a clear description ('Options contract name'). The description itself adds no additional meaning beyond what the schema already provides, so with 100% schema coverage, 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 uses a specific verb ('Get'), identifies the resource ('options contract'), and scopes it to a single instance. This clearly distinguishes it from sibling tools like cex_options_list_options_contracts, which would list multiple contracts.

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 is given on when to use this tool versus alternatives. The description does not mention prerequisites, alternatives, or scenarios. While the word 'single' implies usage for a specific contract, there is no direct comparison to similar list/get tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds no additional behavioral context such as data format, rate limits, or specific constraints. It essentially restates the name without offering extra insights.

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

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

The description is a single sentence, quickly communicating the core purpose without verbosity. It is well-structured and front-loaded with the main action.

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

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

While the schema and annotations cover parameter meanings and safety, the description doesn't explain what a settlement record is, how to interpret the 'at' timestamp beyond schema, or when to use this get tool versus the list tool. For a simple tool this is minimally viable, but gaps remain.

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

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

The input schema provides 100% coverage with descriptions for all three parameters ('Settlement timestamp', 'Options contract name', 'Underlying asset name'). The description adds no additional meaning beyond what the schema already conveys, so the baseline score of 3 applies.

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

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

The description clearly states a specific verb ('Get') and resource ('single options settlement record'), distinguishing from list tools by the word 'single'. However, it doesn't explicitly name alternatives or context, so it is clear but not fully differentiating.

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 information is provided about when to use this tool versus alternatives like cex_options_list_options_settlements. The description lacks any usage context or exclusion criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds no additional behavioral context such as required contract parameter, return format, or pagination. Since the description adds nothing beyond the annotations, the score is low.

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 short sentence, which is concise but under-specified. It conveys the basic action but omits important context like the required contract parameter or the distinction from underlying candlesticks. It is not as empty as a single verb, but it is minimal.

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

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

Given there are 5 parameters (one required) and no output schema, the description is incomplete. It fails to mention the required 'contract' parameter, the optional time range/history parameters, or what the response contains. For a market data tool, this is insufficient.

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

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

The input schema has 100% coverage for all 5 parameters, so the description does not need to explain them. The description provides no additional context or examples, and does not compensate for any gaps since there are none.

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

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

The description uses a specific verb 'Get' and a resource 'options candlestick data', clearly indicating this returns candlestick data for options. However, it does not distinguish between options contract candlesticks and options underlying candlesticks, which are separate sibling tools, so it lacks 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?

There is no guidance on when to use this tool versus alternatives like list_options_underlying_candlesticks or get_fx_candlesticks. No mention of prerequisites or filtering context beyond the schema.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well-covered. The description adds minimal behavioral context beyond stating the listing scope (for an underlying) and does not disclose any unexpected side effects or additional behavior. No contradiction with annotations.

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

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

The description is a single, focused sentence of only seven words. It is fully front-loaded and contains no filler, making it highly efficient and 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 two-parameter listing tool with full schema coverage and strong annotations, the description is adequate. It does not mention the optional expiration filter or response format, but the schema fills those gaps, and the tool's simplicity means minimal additional context is needed.

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

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

Schema description coverage is 100% so both parameters (underlying and expiration) are already documented in the schema. The description adds no additional parameter semantics or examples beyond the schema, so it does not exceed the baseline.

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

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

The description uses a specific verb ('List') and resource ('options contracts') with a clear scope ('for an underlying'), making its purpose immediately obvious. It also distinguishes itself from sibling tools like cex_options_get_options_contract (singular retrieval) and cex_options_list_options_tickers (different resource) by emphasizing 'all contracts'.

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 the tool: when you need all options contracts for a given underlying. It does not explicitly mention alternatives or exclusions, but the naming and 'all' clearly differentiate it from the singular get_options_contract sibling, providing strong contextual usage 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds no behavioral context beyond what the name implies. It does not disclose response format, ordering, or any caveats.

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

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

The description is a single, front-loaded sentence that efficiently communicates the core purpose without unnecessary words.

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

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

For a simple read-only tool with one well-documented parameter and no output schema, the description is sufficiently complete. It could mention output format, but the name and purpose are clear enough.

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

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

Schema coverage is 100% with the parameter 'underlying' described as 'Underlying asset name, e.g. BTC_USDT'. The description's 'for an underlying' merely reiterates the schema, adding no additional semantic meaning.

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 ('List') and resource ('option expiration dates') for an 'underlying'. It distinguishes itself from sibling tools such as list_options_contracts or list_options_tickers.

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. There are no explicit or implicit exclusions, and no sibling tools are mentioned for comparison.

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

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

The description adds no behavioral context beyond what annotations already provide (read-only, idempotent, non-destructive). It does not describe return shape, pagination, depth behavior, or other operational details, so it contributes minimal value.

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

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

The description is a single, clear sentence with no filler words. It efficiently communicates the tool's purpose without waste.

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

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

For a simple retrieval tool with full parameter descriptions and safety annotations, the description is adequate but minimal. It lacks any detail about the order book response structure or behavior (e.g., bid/ask format), which would be helpful given there is no 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 already describes all four parameters (contract, limit, with_id, interval) with complete coverage. The description adds no extra parameter meaning, but given the high schema coverage, a 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 'Get options order book' clearly states the action (get) and resource (options order book), and it differentiates from order book tools for other markets (e.g., cex_spot_get_spot_order_book) by specifying 'options'. However, it is terse and does not mention that a specific contract is required, leaving that to 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 gives no explicit guidance on when to use this tool versus alternatives. Usage is implied by the name and resource: it is for options order books. No exclusions or alternative tools 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and mutability. The description adds no further behavioral context (e.g., pagination, default ordering, or that results may change over time), so it provides minimal value beyond the annotations.

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

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

The description is a single, front-loaded sentence with no redundant detail. It efficiently conveys the core function without unnecessary words, making it very 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?

With 5 parameters and no output schema, the description conveys the essential purpose but omits contextual details like return record structure or pagination behavior. While the schema covers filtering parameters, the tool is simple enough that this might suffice, but it is not fully complete for an agent unfamiliar with the API.

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

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

Schema description coverage is 100% for all 5 parameters, so the schema already documents each parameter. The description only repeats 'underlying' and does not add any meaning beyond the property descriptions, thus meeting the baseline but not exceeding it.

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

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

The description 'List options settlement history for an underlying' clearly states the verb (List), resource (options settlement history), and scope (for an underlying). It distinguishes itself from sibling tools like cex_options_get_options_settlement, which likely retrieves a single settlement, while this lists historical records.

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 its usage context (listing settlement history for a given underlying) but does not explicitly state when to use this vs. alternatives or mention any exclusions. There is no reference to the singular get_options_settlement tool for individual records, so 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description adds no behavioral context beyond the purpose. It does not mention pagination, response format, or any special behavior. No contradiction with annotations, but the description carries no additional transparency burden.

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

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

The description is a single sentence, immediately front-loaded with the action and resource, and contains no wasted words. It is concise and appropriately sized for a simple one-parameter 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?

Given the tool's simplicity (one parameter, no output schema, annotations present), the description is minimally viable but lacks context about what the returned tickers represent or how this differs from similar list/underlying ticker tools. It is not misleading, but it does not fully help an agent select the correct tool among closely named siblings.

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

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

The schema fully describes the only parameter 'underlying' with an example (BTC_USDT), so schema coverage is 100%. The description does not add any extra parameter semantics beyond what the schema already provides, which is the baseline for high 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 'Get options tickers for an underlying' uses a clear verb and resource, and specifies the target as an underlying asset. However, it does not distinguish from very similar sibling tools like cex_options_list_options_underlying_tickers, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description simply states what the tool does without any usage context, leaving the agent to infer the intended use case from the name alone.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description is consistent with a safe read operation. The description adds no extra behavioral context such as pagination behavior or rate limiting, but with annotations covering the safety profile, the minimal description is acceptable.

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 unnecessary words, making it highly efficient.

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

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

Given the 100% schema coverage and annotations indicating a safe read-only operation, the description is sufficient for the agent to understand the tool's function. It doesn't explain return format but no output schema exists, and the description is not misleading. However, it's very minimal and could mention the option to filter by contract or timeframe.

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

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

Schema description coverage is 100%, so all 6 parameters (to, from, type, limit, offset, contract) have descriptions within the schema. The tool description doesn't add parameter meaning beyond the schema, so baseline 3 applies.

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

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

The description uses the specific verb 'List' and identifies the resource 'public options trades', making the tool's purpose clear. However, it doesn't explicitly differentiate from sibling list tools like cex_options_list_options_tickers or cex_options_list_options_settlements.

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

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

The description offers no guidance on when to use this tool versus alternatives; it neither mentions use cases nor excludes other tools. There are many similar list tools in the sibling set, and this description doesn't help the agent choose among them.

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

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

The description is consistent with annotations (readOnlyHint=true, destructiveHint=false), but it adds no behavioral context beyond what annotations already provide. It does not disclose return format, pagination, or any rate limits, though annotations cover the safety profile adequately.

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 immediately conveys the tool's purpose without any fluff or redundant information.

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

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

Given the tool's simplicity, strong annotations, and full schema descriptions, the description is largely sufficient. However, it could briefly mention that the underlying parameter is required or that results are historical data, but the current text is not inadequate enough to warrant a lower 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 description coverage is 100%, so the schema already documents all parameters. The description adds no additional parameter details, such as accepted interval values or timestamp format, aligning with the baseline score for high schema coverage.

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

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

The description clearly states the tool retrieves candlestick data for an options underlying index, using a specific verb and resource. It distinguishes itself from sibling candlestick tools by specifying 'underlying index', such as cex_options_list_options_candlesticks or cex_spot_get_spot_candlesticks.

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

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

There is no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or recommend alternative tools for different scenarios, leaving the agent to infer usage from the tool name and schema.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds the 'all' scope, indicating a comprehensive listing, but provides no additional context about pagination, rate limits, data freshness, or return format. This is moderate value beyond annotations but not rich.

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

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

The description is a single, concise sentence: 'List all options underlying assets'. It is front-loaded with the verb 'List' and directly states the resource with no extraneous words, making it highly efficient and well-structured.

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

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

This is a simple, read-only listing tool with no parameters and no output schema. The description accurately states the purpose, and annotations cover safety and idempotency. It doesn't explain what 'underlying assets' means in the options context or the response structure, but for a tool of this low complexity, the description is reasonably complete.

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

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

The tool has zero parameters, so the schema fully covers all inputs, and the scoring rule sets a baseline of 4. The description does not need to explain parameters, and it does not add any conflicting or confusing information.

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

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

The description uses a specific verb 'List' and explicitly names the resource 'options underlying assets', which clearly distinguishes it from sibling tools like cex_options_list_options_contracts or cex_options_list_options_expirations. The purpose is unambiguous and directly tied to the tool's name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only states the action and resource, without mentioning use cases, prerequisites, or exclusions. There is no differentiation from the many similar list tools beyond the resource name, leaving the agent to infer usage from context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the read-only and safe nature is known. The description adds no extra behavioral context beyond the read-only operation, such as return format or pagination. No contradiction with annotations.

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

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

A single front-loaded sentence delivers the core purpose with zero filler. It is appropriately concise for a tool with one parameter.

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 one parameter and no output schema, the description provides the essential purpose but does not explain the returned ticker data structure or any limitations (e.g., pagination, market data update frequency). However, given the simplicity, it is adequate and not under-specified.

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 100% coverage: the only parameter 'underlying' is described with an example ('BTC_USDT'). The description's phrase 'under an underlying' merely restates the parameter name without adding new meaning. Since the schema fully documents the parameter, the description adds no extra semantic value.

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

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

The description uses specific language: 'Get ticker data for all contracts under an underlying.' It clearly specifies the resource (ticker data) and scope (all contracts under a specific underlying), distinguishing it from generic tools like cex_options_list_options_tickers that likely operate across all underlyings.

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: it is for fetching ticker data for a given underlying. However, it does not explicitly state when to use this over alternatives, nor does it mention any exclusions. The existence of sibling tools like cex_options_list_options_tickers and cex_options_list_options_contracts suggests possible confusion, but the underlying scoping is implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing a safe read operation. The description adds no behavioral details beyond the annotations, such as return format or error behavior. It is consistent with annotations, so no contradiction.

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

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

The description is a single concise sentence that immediately states the tool's purpose. It wastes no words and is front-loaded with the key action and resource.

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 get tool, the description is adequate. However, since there is no output schema, the description could clarify what 'details' include (e.g., currency name, symbol, precision) to fully inform the agent. Still, the tool's simplicity and clear annotations make it mostly 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 100% with a clear description for the single 'currency' parameter ('Currency name'). The description adds no additional meaning beyond the schema, so it meets the baseline for full schema coverage.

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

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

The description uses a specific verb ('Get') and resource ('details of a single currency'), clearly indicating a retrieval operation for one currency. The scope 'single' distinguishes it from sibling 'list' tools like cex_spot_list_currencies, and the tool name reinforces the spot market context.

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 vs alternatives. It does not mention that cex_spot_list_currencies should be used for multiple currencies or that cex_spot_get_currency_pair is for pairs. No exclusions or contextual triggers are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the read-only behavior is covered. The description adds minimal context (that it targets a single pair) but does not disclose any additional behavioral traits such as payload format or rate limits. No contradiction exists.

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

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

The description is a single, front-loaded sentence that states the action and object clearly. Every word earns its place; there is no redundancy or fluff.

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

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

Given the tool's simplicity (1 parameter, no nested objects) and rich annotations, the description is mostly complete. However, the lack of an output schema means 'details' is vague; the agent might not know what fields are returned. Still, the tool name and purpose help fill the gap, and the annotations cover safety aspects.

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%, with the only parameter (currency_pair) fully described in the input schema with an example. The tool description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the action (Get) and resource (details of a single currency pair). It distinguishes from siblings like cex_spot_list_currency_pairs (which lists all pairs) and cex_spot_get_currency (which gets a currency, not a pair), though it does not explicitly name alternatives.

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 'single currency pair' implies use when you need details for one specific pair rather than all pairs, but there is no explicit guidance on when to use this vs. alternatives like list_currency_pairs or get_spot_tickers. Usage context is only implied, not clarified.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds the term 'OHLCV' as an alternative for 'candlestick', which is a minor clarification. It does not contradict the annotations but also does not provide additional behavioral context such as pagination, rate limits, or data ordering. Given the annotations, the bar for additional transparency is lower, and the description meets it with minimal value.

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

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

The description is a single, concise sentence that immediately states the core action and resource. It is front-loaded with the essential information and contains no superfluous words or repetition. Every word earns its place.

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

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

Given the tool's simplicity (a read-only candlestick getter), the description plus schema plus annotations cover the essential aspects. However, there is no mention of the return format (e.g., an array of candlestick objects), and the description does not highlight that this is specifically for spot markets among many sibling candlestick tools. This leaves a minor completeness gap, but it is still adequate for a straightforward data retrieval operation.

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 detailed descriptions for all five parameters, including defaults and constraints, achieving 100% schema_description_coverage. The tool description does not add any parameter-level meaning beyond what the schema already specifies. Therefore, the description adds no value in this dimension, and 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 clearly states the function: retrieving candlestick/OHLCV data for a currency pair. It uses a specific verb ('Get') and identifies the resource ('currency pair'), which aligns with the tool name. However, it does not explicitly say 'spot' or differentiate from sibling candlestick tools for other product types (e.g., fx, dc, options), so it is clear but not fully distinguishing without the name.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as the many other candlestick endpoints for different product categories. There is no mention of use cases, exclusions, or references to sibling tools. The name suggests 'spot', but the description itself lacks any contextual or comparative 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. However, the description adds no additional behavioral context such as default limit, aggregation behavior, or response structure. It is purely a restatement of the tool's basic function.

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 is front-loaded and contains no waste. It delivers the core purpose immediately.

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

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

The tool is simple, with full schema coverage and annotations. However, the description lacks usage guidance and does not describe the return format (no output schema). There are clear gaps in distinguishing from sibling order book tools, making it minimally adequate but not complete.

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

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

Schema coverage is 100%, with all four parameters described in the schema. The description adds no parameter-specific meaning, but it does not need to since the schema is comprehensive. Baseline 3 is appropriate.

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

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

The description clearly states the action ('Get') and resource ('order book for a currency pair'). It is specific enough to identify the tool's function, but it does not explicitly distinguish from sibling order book tools (e.g., cex_fx_get_fx_order_book), relying on the 'spot' in the name.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only says what it does, with no mention of spot vs. other markets or any exclusions. This is a significant gap given the many order book sibling tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safe-read nature is known. The description adds that the tool returns tickers for one or all pairs, but it does not disclose behavioral traits like timezone effects on statistics or return format. No contradiction with annotations.

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

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

A single sentence that is front-loaded and contains no fluff. Every word earns its place, making it easily scannable 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?

With no output schema and simple optional parameters, the description is adequate but not complete. It does not describe what ticker information includes (e.g., last price, volume) or how timezone affects results. The annotations mitigate safety concerns but not return semantics.

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%, with both parameters (timezone, currency_pair) having descriptions. The tool description adds nothing beyond the schema, except the implicit 'one or all' scope already reflected in the currency_pair description. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Get') and the resource ('ticker information'), and defines the scope ('one or all currency pairs'). This distinguishes it from sibling tools like cex_spot_get_currency_pair, which retrieves pair details rather than tickers.

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. Given many sibling tools (e.g., cex_fx_get_fx_tickers, cex_options_list_options_tickers) also offer ticker data, the absence of differentiation or explicit use cases leaves the agent to guess.

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

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

Annotations already cover read-only/idempotent safety, so the description's burden is to add behavioral context. It only adds the vague term 'recent' and doesn't disclose default time range, pagination behavior, or response format. The schema shows time-range parameters, making 'recent' potentially misleading without clarification.

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