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

No contradiction with annotations: readOnlyHint=false, destructiveHint=true, openWorldHint=true, and idempotentHint=true are all consistent with a cancel operation. The description adds valuable behavior beyond annotations by calling out the financial side effect and the requirement to reconcile the account before retrying after an unknown outcome.

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

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

Two tightly written sentences with the main action front-loaded and the critical risk/reconciliation warning immediately after. Every word adds value.

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

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

The operational warning is strong, but a tool with no output schema and zero parameter documentation needs more to be complete: the meaning of confirm, the format/use of clientRequestId, and what a successful cancellation returns are all missing.

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

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

With 0% schema description coverage and four required parameters, the burden was on the description to explain confirm, clientRequestId, symbol, and orderId. It only provides a financial context that hints at why confirm exists; clientRequestId's role as an idempotency key and the need for confirm=true are left implicit.

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 immediately states a specific action ('Cancel an order') on a specific resource, with a consequence ('financial side effect'). This distinguishes it from sibling tools like dzengi_place_order, dzengi_edit_order, and dzengi_close_position.

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 intended use is implied by 'Cancel an order', and the description adds operational guidance about sending the mutation once and reconciling before a retry. However, it does not explicitly contrast with alternatives or state when not to use it.

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

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

The annotations already mark the operation as destructive and non-idempotent; the description adds important context by naming the financial side effect and by instructing reconciliation before any retry. This is genuinely useful behavioral disclosure 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?

Two concise sentences with the purpose front-loaded and the critical retry condition right after. There is no filler or redundant 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 required 4-parameter mutation with no output schema and zero param descriptions, the definition is too thin. It does not describe what confirm is for, what response to expect, or how clientRequestId should be used across retries or reconciliation.

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

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

Schema description coverage is 0%, and the description does not explain confirm, symbol, positionId, or clientRequestId. Only minimal inference is possible from 'close a leverage position'; it fails to compensate for the schema's lack of parameter documentation.

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

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

States a clear action ('Close') and a specific resource ('a leverage position'), plus signals a financial side effect. This clearly distinguishes the tool from the read-only siblings and from position-update 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?

Provides a clear operational instruction: the mutation is sent once, and a retry requires account reconciliation first. It does not explicitly name alternatives or when-not conditions, so it stops short of a 5.

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

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

The description adds meaningful behavioral context beyond the annotations: it characterizes the operation as having a 'financial side effect' and warns that an unknown outcome requires account reconciliation before retry. This complements the readOnlyHint=false and destructiveHint=true annotations without contradicting 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 two focused sentences with no filler. The core purpose is front-loaded, and the second sentence earns its place by warning about retry behavior and financial reconciliation.

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

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

For a mutation tool with six parameters, no output schema, and zero parameter descriptions, the description is not complete enough. It warns about financial side effects, but does not explain what fields like confirm or expireTimestamp do, how orderId relates to clientRequestId, or what the expected outcome/response is.

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

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

Schema description coverage is 0% and the description does not explain any of the six parameters: price, symbol, confirm, orderId, clientRequestId, and expireTimestamp. With no schema descriptions and no parameter guidance in the description, the agent must guess the meaning and constraints of fields like confirm and clientRequestId.

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 and resource: 'Edit an exchange order with a financial side effect.' The verb and object are unambiguous, but it does not differentiate this from the sibling dzengi_update_order, which appears to be the same operation under a different 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 operational cautions about sending the mutation once and reconciling before retry, but it gives no guidance on when to use this tool instead of alternatives such as dzengi_update_order, dzengi_place_order, or dzengi_cancel_order. There is no when-to-use or when-not-to-use advice.

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 and destructiveHint=false, so the description's statement that the call does not change account state is consistent but largely redundant. It adds a little context by specifying 'signed account' permissions, but it does not disclose response behavior, authentication requirements, or any quirks beyond what annotations already cover.

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 states the action, the target resource, and the non-mutating nature of the call in under fifteen words, which is appropriately concise for a simple getter 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?

This is a simple read-only operation with one optional boolean parameter and strong annotations, so the description covers most of what an agent needs. The only real gap is the undocumented showZeroBalance parameter, which keeps it from being fully complete.

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

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

Schema description coverage is 0%, so the description needed to clarify showZeroBalance, but it never mentions the parameter. The name is suggestive, but whether zero-balance entries are included by default or only when true is left ambiguous, and the description adds no meaning beyond the schema field name and type.

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 ('Read') and a specific resource ('signed account permissions and balances'), and it explicitly states the operation does not change account state. This clearly distinguishes it from sibling tools that deal with positions, orders, trades, or market data.

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

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

The description makes the use case clear: call this when you need the signed account's permissions and balances without mutating anything. It does not name an alternative tool or provide explicit when-not-to-use guidance, but the placement among getter tools makes the intended usage 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 establish read-only and non-destructive behavior. The description adds the vague 'bounded' qualifier, implying a limited window/limit, but does not explain time-bound semantics, defaults, or ordering. 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 sentence is compact, with no filler, and places the core action first. It earns high marks for conciseness even though it sacrifices detail.

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 seven parameters, no output schema, and zero schema descriptions, a one-sentence description is not enough for an agent to use optional parameters correctly or understand the return format. The core read intent is clear, but the invocation surface is only partially covered.

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

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

With 0% schema coverage, the description is the only source of parameter meaning. It names symbol and interval, matching the required parameters, but leaves type, limit, startTime, endTime, and priceType undocumented.

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 verb 'Read' with the resource 'candlesticks' and constrains scope to one symbol and interval. This separates it from sibling market-data tools like get_ticker and get_order_book, though 'bounded' is somewhat vague.

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

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

It states that the tool is for candlestick data for a single symbol and interval, which gives a clear context for when to call it. It offers no explicit distinction from siblings or exclusions, so the agent must infer that other market-data tools should be used for non-candle data.

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 it read-only and non-destructive. The description adds that it applies to one normalized symbol, but does not explain what 'supported' means or what the response contains.

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 concise sentence that front-loads the action ('Read') before the object and scope. 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?

Adequate for a simple read-only getter with one parameteranding the meaning of 'normalized symbol' and the shape of the returned leverage settings are not explained, and there is no output schema to fill that 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 0% and the description only says 'one normalized symbol.' It gives no example, format, or definition of normalization, leaving the agent to guess what value to supply.

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

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

Names a clear verb and object: 'Read supported leverage settings for one normalized symbol.' This distinguishes it from sibling getters like get_trading_fees or get_account, though 'normalized symbol' is unexplained.

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 purpose implies when to call it — when leverage settings for a symbol are needed — but there is no explicit guidance about when to prefer this over sibling tools, nor any 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 indicate readOnlyHint=true and destructiveHint=false, so the description doesn't contradict them. It adds the 'signed order' descriptor, which hints at a specific state but doesn't explain consequences or additional behavior. Given the annotations cover safety, the description adds minimal new behavioral context, appropriate for a simple read.

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, extremely concise and front-loaded with the core action. No redundant words, every word contributes.

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 getter tool with two parameters and no output schema, the description is minimal. It doesn't describe the return structure, the meaning of 'signed order', or any edge conditions (e.g., whether the order must be active or historical). Given the sibling tools like list_open_orders, more context on what a signed order is and how it differs would help. The tool is simple, but the description leaves gaps in understanding what the agent can 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?

With 0% schema description coverage, the description has the burden to explain the parameters. It only names them ('symbol and order ID') and marks them required, which is already in the schema. It doesn't explain what symbol means (e.g., instrument identifier) or what constitutes a valid order ID, so it fails to add semantic value over the schema.

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

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

The description clearly states the action (read) and the resource (one signed order), specifying that it retrieves a single order by symbol and order ID. It distinguishes from list-type operations but does not reference any sibling or alternative, so it's clear but not differentiated.

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

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

No guidance on when to use this tool versus alternatives like list_open_orders or list_trades. It does not mention prerequisites (e.g., need the order ID) beyond the schema's required fields, nor does it say when not to use it. No context or exclusions 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 mark the operation read-only and non-destructive; the description adds useful behavioral detail: the snapshot is 'public' and 'bounded', setting expectations about access and depth. 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 with no filler; every word adds semantic value.

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

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

For a simple two-parameter read tool, the description plus annotations cover the safety profile and core behavior. It lacks an explicit statement of return shape, but no output schema exists and the order-book return value is largely inferable from the 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?

With 0% schema description coverage, the tool description must compensate for parameter meaning. It hints at 'one symbol' and 'bounded' to map to symbol and limit, but it does not explicitly describe limit's role, optionality, or format; the schema's min/max carry part of that 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?

Description uses a specific verb ('Read') with a clear resource ('public order book snapshot') and scope ('for one symbol'), immediately distinguishing it from sibling tools like get_ticker or get_candles. The word 'bounded' also foreshadows the limit parameter.

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

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

It clearly states the context: a public, per-symbol order book read, which tells an agent when this tool is relevant. It doesn't name explicit alternatives or exclusions, but no sibling tool competes for the order-book use case, so the omission is minor.

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 establish read-only and non-destructive behavior. The description adds a meaningful behavioral trait – 'credential-safe' – signaling that the call does not leak sensitive informationable. It does not mention response shape or possible empty states, but for a read-only status probe the added context is sufficient.

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 compact sentence communicates the return content in under 12 words. No filler, no repetition of the tool name or schema.

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

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

For a parameterless read-only status tool, the annotation set plus the description is sufficient for an agent to understand the call is safe, needs no arguments, and returns runtime configuration and enabled safety gates. Nothing essential is missing.

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

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

The tool takes zero parametersessed and the schema fully documents an empty parameter set. With no parameters to explain, the description adds no further semantic burden; baseline 4 is appropriate.

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

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

The description uses a specific verb ('Return') and a clear resource: credential-safe runtime configuration and enabled safety gates. It is immediately distinguishable from the sibling tools, which target accounts, orders, candles, fees, and similar domain data.

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

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

The intended use is implied by the tool name and description – call it to inspect runtime configuration and safety gates. However, there is no explicit guidance on when to prefer this over sibling getters, nor any context about environment state 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the side effect of refreshing the client's clock offset, which is a behavioral detail not captured by the annotations. This is valuable beyond the structured data.

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 that states the primary action and the side effect with zero wasted words. Perfectly sized for a tool with no 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?

For a zero-parameter, read-only tool with no output schema, the description fully covers what it does and the side effect. Annotations handle safety. Nothing an agent needs to invoke it correctly is missing.

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

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

The tool has zero parameters, so the schema is empty and there is nothing to document. Baseline for zero-param tools is 4; the description correctly avoids adding unnecessary 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 states a specific action: reads the current server time and refreshes the client's clock offset. This clearly distinguishes it from sibling tools that handle positions, orders, or market data. The verb 'Read' and the resource 'server time' are explicit.

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

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

No explicit guidance is given on when to use this tool vs alternatives, but its purpose is unique and obvious (clock synchronization). The description implies usage for time-related operations, but does not mention exclusions or alternatives. Since there is no competing tool, implied usage is adequate but not explicitly stated.

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

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

Annotations already mark the operation as read-only and non-destructive. The description adds 'public' and '24-hour' scope but does not disclose rate limits, possible empty results, or formatting behavior. The annotations cover safety, but the description adds only modest behavioral context.

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

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

A single sentence that leads with the core action ('Read the public 24-hour ticker') and immediately appends the optional filter. Every word is informative, with no filler or repetition of schema fields.

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

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

For a simple read-only endpoint with one optional parameter, the description gives enough to understand the basic call. It is weak on what a 'ticker' contains, what 'normalized' symbol means, and what the response implies when omitted. No output schema exists, so a bit more detail about return shape would help.

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 minimal (only a maxLength constraint), so the description must carry the meaning. It clarifies that the symbol filter is optional and the symbol should be 'normalized', which adds value, but it does not define what normalized means or what symbol formats are accepted.

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

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

States a specific verb ('Read') and a specific resource ('public 24-hour ticker'), and notes an optional symbol filter. This clearly identifies the operation and distinguishes it from sibling tools like get_candles or get_order_book.

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

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

The description makes the use context clear: you call this when you want the public 24-hour ticker, optionally filtered by symbol. However, it does not explicitly state when not to use it or mention alternatives such as get_order_book or get_candles.

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 establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the data is public and that an optional symbol narrows the result, which is useful beyond the annotations. It does not describe pagination or return shape, but this is acceptable for a simple read-only lookup.

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 with no filler. It states action, resource, and optionality in under ten words, and every part of the sentence earns its place.

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

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

For a read-only, zero-required-parameter tool, the description covers what resource is read and how filtering works. No output schema exists, so the absence of an explicit return-shape description leaves a small gap, but this is unlikely to prevent correct invocation. Combined with annotations, the definition is effectively complete for its 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 0%, so the description must carry meaning for the 'symbol' parameter. 'Optionally filtered by symbol' conveys the parameter's role and optionality, which the bare schema lacks. It does not specify symbol format or valid values, but the parameter is simple and self-descriptive enough for baseline adequacy.

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 uses specific verb 'Read' plus resource 'public trading fee information' and adds an optional symbol filter, so an agent knows exactly what resource is exposed. The resource is distinct from sibling getters like dzengi_get_trading_limits or dzengi_get_leverage_settings.

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 'public trading fee information' gives clear context: use this tool when the agent needs exchange fee data rather than account state or trading limits. 'Optionally filtered by symbol' provides basic selection guidance. It does not explicitly name alternatives or exclusions, but the context is clear enough for a single-purpose tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds little beyond 'public', implying no auth, but doesn't disclose behavior like default return scope (e.g., all limits when no symbol given) or any response format. With annotations covering safety, the description adds minimal extra 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?

The description is a single, front-loaded sentence that states the action and the optional filter with zero waste. Every word earns its place, making it concise 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 with one optional parameter and no output schema, the description is adequate but incomplete. It doesn't describe what the response contains (e.g., a list of limits, a single object) or clarify what 'trading limits' refers to. This could leave an agent uncertain about the return value, though the tool's simplicity mitigates the gap.

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

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

The schema has zero description coverage for the 'symbol' parameter, so the description must compensate. It does clarify that the symbol is optional and used for filtering, which adds meaning beyond the schema's type/maxLength. However, it doesn't specify the expected symbol format or what happens when omitted, leaving some ambiguity.

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 'Read' and the resource 'public broker trading limits', making the tool's purpose explicit. It distinguishes itself from sibling tools like trading fees or leverage settings by its specific subject matter, even though it doesn't 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 description gives no explicit guidance on when to use this tool over alternatives like dzengi_get_trading_fees or dzengi_get_leverage_settings. It only states its function, leaving the agent to infer usage context from the tool name. There are no exclusions or alternative suggestions.

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 meaningful behavioral context: it guarantees bounded local pagination and explicitly warns against unbounded exchangeInfo payloads. This goes beyond the annotations by disclosing a performance/response-size guarantee.

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

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

The description is a single sentence that front-loads the core action and constraint. Every word earns its place: 'Read exchange instruments' states the purpose, 'bounded local pagination' states the mechanism, and the warning clause prevents misuse. No filler or redundancy.

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

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

For a simple read-only paginated list with two self-explanatory parameters and annotations covering safety, the description is nearly complete. The only gap is that it doesn't describe the return shape or whether the response includes total counts, but with no output schema and a simple list tool, the bounded-pagination warning is the most important context and it is present.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. However, the description does not explain 'limit' or 'offset' semantics beyond what the schema's names and numeric bounds already imply. The pagination mention in the description loosely maps to offset/limit, but it adds no detail about defaults, ordering, or how pagination behaves. Baseline 3 is appropriate because the parameter names are self-explanatory and the schema provides bounds.

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

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

The description states a specific verb ('Read') and resource ('exchange instruments'), and adds a scoping constraint ('bounded local pagination'). It distinguishes itself from the broader exchangeInfo payload concern, though it doesn't explicitly name a sibling alternative. The purpose is clear and actionable.

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

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

The description implies usage context: it is a read-only paginated listing tool, and the warning about never returning an unbounded exchangeInfo payload suggests when to use it (when a bounded list is needed). However, it does not explicitly state when to prefer this over siblings like dzengi_list_positions or dzengi_get_ticker, nor does it mention any exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds the 'currently open' state scope and the 'normalized symbol' behavior, but does not disclose output format, ordering, or pagination.

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 with no filler. The core action and the optional parameter behavior are both front-loaded and immediately usable.

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 operation with one optional parameter)Skip enriched by readOnly and openWorld annotations, the description is adequate for selection and invocation. It does not describe the return payload, but that is a minor gap for this 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?

Schema coverage is 0% and only provides type and maxLength for symbol. The description adds valuable meaning: the symbol parameter is optional and will be normalized, which is essential information the agent would otherwise lack.

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 uses a specific verb ('read'), a clear resource ('currently open orders'), and a precise qualifier ('optionally filtered by a normalized symbol'). It distinguishes the operation from general order fetching.

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 'currently open orders' gives clear context and implicitly excludes historical, cancelled, or filled ordersholistically. It does not name sibling tools like dzengi_list_positions or dzengi_get_order, but the context is sufficient for typical 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds minimal extra behavioral context. It mentions 'bounded' which hints at limit-driven pagination and 'signed' (long/short), but does not describe return format, ordering, or any side effects. This is adequate given the annotations cover safety, but it is not rich 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 sentence that front-loads the primary action and includes all essential scoping (bounded, signed, filters) without verbosity. It is appropriately concise for a simple read tool, though it could expand slightly without losing efficiency.

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 4 parameters, no required fields, no output schema, and moderate complexity, the description is too sparse. It does not explain the meaning of 'signed', the relationship between from/to and pagination, or what the return value contains. The agent would need to infer or probe further to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It names 'time and symbol filters' and 'bounded', but does not explicitly map to specific parameters (from, to, symbol, limit) or explain their types and semantics (e.g., whether from/to are timestamps, what 'signed' means for the data). This leaves the agent guessing about parameter 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 a specific verb ('Read') and resource ('position history'), and distinguishes it from the sibling dzengi_list_positions by explicitly saying 'history' rather than current positions. The mention of 'bounded' and 'filters' further sharpens the scope without 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 word 'history' implies it is for past positions and not current ones, but it does not explicitly state when to use this tool versus dzengi_list_positions or mention any exclusions. There is no direct callout to alternatives or distinct use cases, leaving the routing to inference.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral detail such as pagination, sorting, or whether a snapshot of all positions is returned, though it 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, front-loaded sentence with no filler. Every word ('current', 'signed', 'leverage positions') adds meaning.

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

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

For a zero-parameter read-only tool with full annotation coverage and no output schema, the description is sufficient: it names the resource returned and the operation. A longer return-format description is unnecessary given the low complexity.

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

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

There are zero parameters and schema coverage is 100%, so there is no parameter semantics burden on the description. The sentence correctly implies the tool requires no inputs.

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

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

States the verb 'Read' and a specific resource ('current signed leverage positions'), which immediately separates it from the history/mutation siblings (list_position_history, close_position, update_position). The term 'signed' adds semantic precision about long/short direction.

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 obtaining the current set of leverage positions, but it does not explicitly state when to prefer it over list_position_history or list_open_orders, nor does it name exclusions. It provides implied usage rather than explicit routing.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safe read-only nature is clear. The description adds only 'bounded' as behavioral context, which likely refers to the limit parameter, but it doesn't describe pagination, return format, or error behavior. The added value over annotations is minimal.

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

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

The description is a single, compact sentence that conveys the core action without fluff. It is well-structured and easy to parse, even if it lacks depth.

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 4 parameters, zero schema coverage, and no output schema, the description is incomplete. An agent lacks essential details about parameter semantics, constraints (e.g., startTime < endTime), and expected response. The read-only annotation covers safety, but not the operational details needed to call 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?

The schema provides no descriptions (coverage 0%), so the tool description must carry the burden. It mentions 'symbol' and 'optional time filters', which likely map to startTime and endTime, but doesn't explain limit, the meaning of 'bounded', or time formats (e.g., milliseconds since epoch). This is insufficient for an agent to correctly construct calls.

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

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

The description clearly states it reads user trades for a single symbol with optional time filters, which is specific and distinguishes it from position-related tools like dzengi_list_positions and order-related ones. However, 'signed' is ambiguous, and it could better differentiate from dzengi_list_position_history, which might overlap in concept.

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 fetching trades with symbol and time constraints, but it doesn't explicitly state when to prefer this over alternatives like dzengi_list_positions or dzengi_list_position_history. There are no exclusions or explicit conditions that an agent can rely on to decide between siblings.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=true, idempotentHint=false. The description adds value by stating the financial side effect and the requirement for account reconciliation on unknown outcomes, which goes beyond the structured hints. It reinforces non-idempotency and the need for caution. 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 two sentences with no filler. The primary purpose is front-loaded, and the critical non-idempotency warning is placed second. Every sentence earns its place.

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

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

Despite the tool's complexity (17 parameters, 6 required, no output schema, no enums), the description provides only the purpose and retry warning. It does not explain parameter semantics, return values, error handling, or how to construct a valid order. For a mutation with significant financial impact, this is insufficient. The description covers only a small fraction of what an agent needs to call it correctly.

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

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

Schema description coverage is 0% – the schema provides no descriptions for any of the 17 parameters. The tool description adds zero parameter information. It does not explain required fields, acceptable values, or relationships between parameters (e.g., how price, stopLoss, takeProfit relate to order type). The agent is left to infer everything from parameter names alone, which is inadequate for such a complex order placement tool.

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

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

The description clearly states the action: 'Place an order' – a specific verb and resource. It distinguishes this from siblings like get_order, cancel_order, and edit_order. The phrase 'with a financial side effect' reinforces the mutating nature, 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 provides guidance on retry behavior – 'sent once' and 'requires account reconciliation before any retry' – which is useful for when not to retry blindly. However, it does not explicitly compare to alternatives like preflight_order (for testing without execution) or edit_order (for modifying existing orders). It implies usage for placing new orders but doesn't contrast with siblings.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the core safety profile is provided by structured data. The description adds that validation occurs against fresh broker metadata and configured policy, which gives some behavioral context, but it doesn't describe what happens on failure, what is returned, or any side effects beyond what annotations state.

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 wasted words. It captures the tool's purpose and boundary condition in a tight statement, which is a model of 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?

The tool is a 17-parameter validation operation with no output schema and no description of the returned validation outcome or failure behavior. The description is too minimal to allow an agent to know what parameters require attention or what a result means, making it incomplete in 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?

With 17 parameters and 0% schema description coverage, the description was expected to compensate heavily, but it only refers generically to an 'order intent'. It gives no meaning to key parameters such as side, type, quantity, price, timeInForce, or accountId, leaving an agent to guess at their roles.

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 ('validate') and resource ('order intent'), and explicitly distinguishes this from order placement with 'without placing it.' This clearly surpasses the tautological baseline and positions it against the sibling place_order tool.

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

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

The description makes the primary usage context clear: it is a validation step that does not place an order. It doesn't explicitly name an alternative tool or exclusion conditions, but the 'without placing it' qualifier is a clear, actionable hint for when to use this over a placement tool.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=true, and openWorldHint=true. The description adds valuable context beyond annotations: the mutation has a financial side effect, is sent once, and an unknown outcome requires account reconciliation before retry. This clarifies the idempotency semantics (despite idempotentHint=true, retries are dangerous without reconciliation) and the destructive nature. No contradiction with annotations; it enriches 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?

Two sentences with no filler. The first sentence states the action and consequence; the second gives a critical operational warning. Every word earns its place, and the most important behavioral caveat is front-loaded.

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

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

Given the tool's complexity (12 params, financial side effect, no output schema), the description is too thin. It covers the critical retry/reconciliation behavior but omits what the parameters do, what a successful response looks like, and how this differs from dzengi_edit_order. The annotations cover safety profile, but the description doesn't provide enough for an agent to confidently invoke this mutation correctly.

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

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

Schema description coverage is 0%, so the description must compensate for 12 parameters, but it mentions none of them. The description doesn't explain what 'leverage-order protection' means for parameters like stopLoss, takeProfit, trailingStopLoss, guaranteedStopLoss, or how confirm and clientRequestId interact. With 0% coverage and no parameter explanation, the agent is left to infer semantics from names alone, which is insufficient for a financial mutation.

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 ('Update') and resource ('leverage-order protection') and adds a critical qualifier ('with a financial side effect'). It distinguishes itself from generic order editing by emphasizing the financial consequence, which helps differentiate it from siblings like dzengi_edit_order. However, it doesn't explicitly name the sibling it is not, so it's clear but not fully differentiated.

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 this tool: when updating leverage-order protection, and it warns that the mutation is sent once and retries require account reconciliation. This gives clear context for use and a caution about retry behavior. It doesn't explicitly list alternatives or when-not-to-use, but the warning about financial side effects and reconciliation provides practical 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?

Although annotations already indicate mutation and destructiveness, the description adds crucial behavioral context: it is a financial side effect, it must be sent once, and unknown outcomes require account reconciliation before retry. This meaningfully extends beyond the structured annotations and tells the agent how to treat the operation safely.

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 only two sentences long, with the primary action and side effect stated first, followed by the critical retry guidance. Every sentence earns its place, and there is no redundant or filler 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?

Given the tool has ten parameters, no output schema, and zero schema parameter descriptions, the description is not sufficient for an agent to know how to construct a correct request. It communicates the high-level safety behavior but omits the semantics of the required fields and expected responses, leaving a significant gap for a complex financial mutation.

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

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

Schema description coverage is 0%, yet the description provides no explanation of the ten parameters, including required fields like clientRequestId, confirm, symbol, and positionId, or optional protection fields like stopLoss, takeProfit, and trailingStopLoss. The description does not compensate for the schema's complete lack of parameter documentation.

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

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

The description states a specific action and resource: 'Update leverage-position protection', and flags that it carries a financial side effect. It is clear about what the tool does, though it does not explicitly differentiate itself from sibling tools such as close_position or edit_order.

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

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

The description gives a clear operational constraint: the mutation should be sent once, and an unknown outcome requires account reconciliation before retrying. It does not explicitly compare this tool to alternatives, but it provides a practical usage boundary for a financially sensitive operation.

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