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

With no annotations, the description carries the full burden. It discloses that omitting credentials results in public/read-only mode and that secret fields are never returned. It does not mention mutation side effects or permissions, but the added context is valuable.

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

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

The description is two sentences, front-loaded with the primary action, and every sentence adds meaningful information 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?

Despite having 7 parameters and no output schema, the description covers key behavioral aspects (mode and secret handling) but omits return values, error conditions, and details for other parameters. It is minimally viable but lacks depth for a complete 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?

Schema description coverage is 0% and only api_key/api_secret are explained in the description. Other parameters like label, tags, market, request_id, and idempotency_key are left undocumented, so the description insufficiently compensates for the schema's lack of descriptions.

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

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

The description clearly states the action ('ekler' = adds) and the resource ('spot hesap' = spot account), making it obvious this creates an account. It also distinguishes from sibling tools like list_accounts and remove_account.

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 on when to omit api_key/api_secret (for public/read-only mode) but does not explicitly mention alternatives or exclusions. However, this is a unique add operation, so ambiguity is low.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses that the operation has no calculation impact and is saved persistently, but it does not mention whether annotations are appended or replaced, any permission requirements, or idempotency 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, front-loaded sentence that directly states the action and key effects. It contains no filler and is appropriately sized for the tool's complexity.

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

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

The description covers the core purpose and two important behavioral traits, but with six parameters and no output schema, it leaves gaps around overwrite semantics, idempotency, and optional parameter roles. Overall, it is minimal but not fully complete.

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

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

Schema description coverage is only 17%, so the description must compensate. It clarifies the target (symbol+timeframe) and gives an example shape for the annotations parameter, but it does not explain the optional parameters created_by, request_id, or idempotency_key.

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 action: adding agent annotations to a symbol+timeframe, with an example shape. This distinguishes it from siblings like get_chart_annotations and clear_annotations, which retrieve or remove annotations.

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 use case is implied: annotate a chart for a given symbol/timeframe. It adds context that this has no effect on calculations and is persistent, but it does not explicitly state when to prefer this over get_chart_annotations or clear_annotations, nor does it mention exclusions.

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

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

With no annotations, the description carries full burden and does so excellently: it discloses that this is a real-money mutation, explains daemon-side sizing using risk_pct and equity, and states the idempotency mechanism that prevents duplicate orders on retry. This goes well beyond a generic 'approve order' 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 three concise sentences: action, sizing, and idempotency/risk. Every sentence adds value with no redundant filler, and the purpose 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?

The description covers the core action, real-money risk, sizing logic, and idempotency, which is sufficient for the tool's complexity. It omits return values and failure behavior, but with no output schema and a straightforward action, this is not a critical gap. The only notable omission is detailed parameter purpose.

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 0% description coverage, and the description only indirectly hints at order_id via 'pending:<order_id> key' and idempotency. It does not explain request_id or clarify the exact relationship between idempotency_key and the pending key, leaving the agent to infer parameter meanings.

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 and resource: 'approves the pending order and opens it as a REAL order.' This distinguishes it from sibling tools like reject_pending_order and place_order.

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

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

The description explicitly warns to call only with the user's explicit approval ('yalnızca kullanıcının açık onayıyla çağrılmalı'), providing a clear when-not-to-use constraint. It does not explicitly name alternatives, but the context makes the intended use 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?

With no annotations, the description carries the full burden and does so excellently. It details the calculation steps, fee deduction, rounding down based on LOT_SIZE/MIN_NOTIONAL/PRICE_FILTER, the FILTER_VIOLATION fail-closed return, and active validation checks (stale price, wrong stop direction, unknown symbol, insufficient balance).

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, densely packed with essential information. Each sentence earns its place: the first covers the calculation and rounding, the second covers validations and error behavior. There is zero 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?

The description comprehensively covers the algorithm, failure modes, and validation for a calculation tool. The lack of an explicit success return format (since no output schema exists) is a minor gap, but the behavioral details largely compensate.

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

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

Schema coverage is only 44%, but the description compensates by explaining the roles of core parameters (account_balance, risk_pct, entry, stop_loss, fee_rate) in the formula. It also adds context about rounding and error behavior. Metadata parameters like request_id and idempotency_key are not explained, but they are straightforward.

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 calculates risk-based position size with a specific formula (account_balance * risk_pct divided by risk-per-unit, fee deducted, rounded down by exchange filters). It distinguishes itself from order execution tools by focusing on the calculation aspect and mentioning validation and error handling.

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 is implied: it computes position size before trading. However, there is no explicit comparison to sibling tools like place_order or place_oco_order, nor any exclusions. The description does not explicitly say 'use this when' or 'don't use when'.

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

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

No annotations are provided, so the description bears full responsibility for disclosing behavior. It clearly states the destructive action ('deletes all') and the output (deleted count), which is important safety information. However, it doesn't mention irreversibility or any additional side effects, so it's not a 5.

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

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

The description is a single sentence that efficiently conveys the action, scope, and return value. There is no wasted information, and it is front-loaded with the core 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?

The tool is simple, and the description covers the essential behavior and return count. It lacks explicit handling of edge cases (e.g., no annotations) and the optional parameters' purpose, but the description is largely self-contained given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It clarifies that symbol and timeframe define the scope of deletion, but it doesn't explain the purpose of request_id or idempotency_key. The description adds some value over the raw schema but leaves the optional parameters undefined.

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 'siler' (deletes) and clearly identifies the resource: annotations for a given symbol and timeframe. It also states the return value (deleted count), distinguishing it from siblings like get_chart_annotations and annotate_chart.

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 this tool is for clearing all annotations for a symbol/timeframe, but gives no explicit guidance on when to use it over alternatives or any exclusions. It doesn't mention that it should be used before re-annotating or that it is the inverse of adding annotations.

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

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

With no annotations, the description carries full burden and discloses key behaviors: partial success reporting, idempotency (no double selling), paper account simulation (closed=false, simulated=true), and audit log writing. This is exceptionally transparent.

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

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

Four sentences, each providing distinct value: purpose, partial success behavior, paper account behavior, and audit logging. It is front-loaded and free of padding.

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

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

The description covers many important edge cases (partial success, idempotency, paper trading, audit log) but does not describe the normal response structure or error handling for invalid account_id. Still, it is fairly complete for a complex trading 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 only 33%; the description compensates by explaining the special 'all' value for account_id and noting idempotency which relates to idempotency_key. However, request_id remains unexplained.

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: canceling open orders and selling base asset balances at market price, with scope ('all' accounts). It clearly distinguishes itself from sibling tools like place_order or get_open_orders by focusing on liquidation.

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 closing positions but never explicitly says when to use it vs. alternatives. It provides special-case context (all accounts, paper accounts) but no direct 'use this instead of X' guidance.

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

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

With no annotations, the description carries the full burden and goes beyond a basic definition by disclosing the state machine (armed→triggered→cooldown→armed) and deduplication behavior (same data window not retriggered). It does not mention the pending order side effect, but that is already detailed in the order_spec parameter schema, so the description adds meaningful behavioral context without contradicting 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, efficiently providing purpose, scope, condition reference, state machine, and dedup behavior. Every sentence carries substantive information 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 tool's complexity (8 parameters, nested objects, no output schema), the description covers core behavior and state transitions but omits what the tool returns and how the alert integrates with sibling tools like list_alerts or get_triggered_alerts. The side effect of creating a pending order is in the schema, but the overall lifecycle is incomplete without return value info.

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

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

Schema description coverage is only 25%, so the description needs to compensate. It adds semantics for 'condition' (same AST as scan_market) and implicitly explains 'cooldown_seconds' via the state machine, but leaves other parameters like note, idempotency_key, and request_id unexplained. This is a partial compensation for the low 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 it defines a conditional alarm for a single symbol and timeframe, with a specific verb and resource. It distinguishes itself from create_composite_alert by explicitly limiting scope to a single symbol+timeframe, 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?

It provides clear context that the condition uses the same allowlisted filter AST as scan_market, giving the agent guidance on how to construct the condition. The single-symbol+timeframe scope implies when to use this tool over composite alerts, though it does not explicitly name alternatives or exclusion scenarios.

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

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

With no annotations, the description carries the full burden. It discloses the stale data behavior (clauses must be fresh to be evaluated), which is a useful behavioral detail. However, it does not mention creation side effects, idempotency, or permission requirements, leaving gaps in transparency.

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

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

The description is two sentences, front-loaded with the core purpose and a concise behavioral note. Every word earns its place, with no waste 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 create operation with no output schema and no annotations, the description is thin. It explains the core mechanism but omits return value information, prerequisites, and operational context. An agent would need additional detail to confidently invoke this tool and handle the response.

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

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

Schema description coverage is 0%, so the description fully compensates for parameters. It clarifies the 'clause' concept (symbol/timeframe pair + condition) and the AND/OR combine logic, which helps with the 'clauses' and 'combine' parameters. But it does not explain 'cooldown_seconds', 'idempotency_key', 'request_id', or 'note', leaving most parameters semantically unexplained.

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 creates an alert that combines multiple clauses with AND/OR logic, which is a specific action and resource. It distinguishes from the sibling 'create_alert' by emphasizing the composite nature of the alert.

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 multi-clause alerts but does not explicitly state when to use this over 'create_alert' or provide exclusions. The context is clear enough for an agent to infer, but it lacks explicit when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the deletion action, omitting whether deletion is permanent, requires special permissions, or has side effects like deactivating triggers.

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

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

The description is a single, efficient sentence with no wasted words. It is appropriately concise, though it sacrifices detail for brevity.

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

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

With no output schema and no annotations, the description should at least explain the return value, error conditions, or which parameters are needed. It does none of these, making it incomplete for a delete operation despite low tool complexity.

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

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

The schema has 0% description coverage, and the description does not explain any parameters. While parameter names like alert_id and idempotency_key are somewhat self-explanatory, the lack of required parameters and absence of any guidance on their usage leaves the agent guessing.

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 'Alarm tanımını siler' clearly states the action (delete) and the resource (alert definition), which is specific and distinguishes it from sibling tools like create_alert and list_alerts.

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

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

No explicit guidance on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. The usage is implied from the purpose, but the description does not provide clear context 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?

With no annotations, the description carries the transparency burden. It discloses key behaviors: it blocks new orders, writes to the audit log, and is idempotent when already in paper mode. This goes beyond the bare action, though it does not cover permissions or the fate of existing orders.

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 front-loads the critical 'Kill switch' concept. Every clause adds value: purpose, effect, audit logging, and idempotency. 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 action with no output schema and few parameters, the description adequately covers the main aspects: what it does, the side effect, and idempotency. It stops short of explaining error conditions or return values, but these are not critical for using 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 only 33% (only account_id is described). The description repeats the 'all' special value but provides no additional meaning for request_id or idempotency_key, despite the term 'idempotent' hinting at the latter. It fails to compensate for the low 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?

Description clearly states a specific verb ('converts') and resource ('trading lock'), and specifies the direction ('real' to 'paper'). The 'Kill switch' framing and the effect 'new orders are not sent' make it unmistakable and distinct from sibling tools like enable_real_trading.

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 'Kill switch' label implies emergency use to stop real trading, and the description clarifies the effect (no new orders) and idempotency. It does not explicitly name alternatives or exclusions, but the context is sufficiently clear for a specialized action.

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

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

With no annotations, the description carries the full burden and does well: it discloses permanence, one-way nature, idempotency, rejection without credentials, and audit_log side effect. It does not mention potential risks or permission requirements beyond credentials.

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, dense with information and no redundancy. It is appropriately sized and front-loaded with the core 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?

The description covers key behavioral aspects (permanence, idempotency, preconditions, audit) but leaves gaps: no explanation of request_id/idempotency_key parameters, no mention of return value or error cases beyond credential-less rejection. Given no output schema and minimal schema, it is not fully complete.

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

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

Schema coverage is 0%, so the description must compensate. It hints at 'account' but does not explain 'account_id' directly, and completely omits 'request_id' and 'idempotency_key' despite mentioning idempotency as a property. The description adds little beyond the schema.

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

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

The description clearly states the action: permanently converting the account's trading lock to 'real', with specific details like being one-way and idempotent. This distinguishes it from sibling 'disable_real_trading'.

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 (when enabling real trading) and a precondition (account must have credentials), but it does not explicitly mention alternatives or when not to use it. No comparison to sibling tools like 'disable_real_trading'.

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

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

With no annotations, the description carries the full burden and succeeds: it discloses UNION logic, empty-target rejection, daemon-side order sizing independent of agent figures, idempotency behavior, per-account partial results, and always-on sanity checks. This is comprehensive and goes well beyond basic expectations.

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 five-sentence description is tightly packed, with the core purpose front-loaded and each subsequent sentence covering a distinct behavioral aspect. There is no redundancy, fluff, or irrelevant 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?

For a complex tool with 10 parameters and no output schema, the description covers the most critical aspects: targeting, sizing, idempotency, partial success, and validation. However, it does not specify the exact response structure (beyond 'separate result per account') or prerequisites like account existence, leaving some gaps for an agent to infer.

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

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

Schema coverage is only 30% (tags, symbol, account_ids have descriptions), so the description must compensate. It adds meaningful context for idempotency_key (duplicate prevention), account_ids/tags (UNION), and risk_pct (daemon-computed sizing), but leaves entry, stop_loss, order_type, side, and request_id to the schema. Side and order_type are self-explanatory via enums, yet prices and request_id remain underspecified.

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 first sentence, 'Birden çok hesapta pozisyon açar' (Opens positions on multiple accounts), states a specific verb and resource with an explicit multi-account scope. This clearly distinguishes it from single-account siblings like place_order or place_oco_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 implies usage for multi-account execution and provides account-targeting rules (UNION semantics, rejection when both are empty), but does not explicitly name alternatives or when-not-to-use conditions. It gives operational context but no tool-selection guidance relative to siblings.

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

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

With no annotations, the description carries the full burden. It discloses that the tool uses the daemon's own fresh balance/price snapshot to compute holdings value and total equity, which is a useful behavioral detail. It does not explicitly state that it is read-only or if calling it triggers any snapshot refresh, but the wording 'returns' and 'view' implies a read operation.

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 efficient and well-structured, leading with the main purpose, then breaking down the return components, and adding a clarifying sentence on total value and snapshot use. No 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?

The return value is thoroughly explained, which is important given no output schema. However, the parameter semantics are entirely absent, and there is no guidance on error conditions or invocation context, leaving the tool only partially complete for an agent.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no information about the parameters. The only hint is 'Hesabın' which relates to account_id, but request_id and idempotency_key are completely unaddressed, leaving the agent without guidance on their purpose.

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

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

The description clearly states the tool returns the full account balance, breaking down free, locked, holdings value, and total equity, and emphasizes it goes beyond just free balance. This distinguishes it from a simpler balance query and is specific to the account resource.

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

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

It provides clear context: this tool returns the real total value of the account, not just the free balance, indicating when it should be used for comprehensive balance information. However, it does not explicitly mention alternatives or provide when-not-to-use guidance, though the emphasis on 'tam bakiye' implies it's the go-to for full balance.

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

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

With no annotations, the description carries the full burden. It discloses that the response includes a 'verified' boolean indicating chain integrity and notes that broken rows may be present. However, it omits other behavioral details such as pagination, default limits, rate limits, or whether the operation is read-only, which would be expected for a query 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, tightly worded sentence (in Turkish) that immediately conveys the core functionality and key output flag. No wasted words; it 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 3 unannotated parameters and no output schema, the description is incomplete. It explains the 'verified' flag but leaves out parameter semantics, response structure, and any usage caveats. A more thorough description is needed for a tool with this complexity.

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

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

The input schema has 3 parameters with 0% coverage (no descriptions), and the tool description does not explain any of them. The meaning of 'limit', 'request_id', and 'idempotency_key' is entirely absent, failing to compensate for the schema's lack of 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 clearly states the tool queries an audit log with hash-chain verification, using a specific verb ('query') and a specific resource ('audit log'). It distinguishes from siblings by mentioning hash-chain verification, but does not explicitly contrast it with other log-related tools, so it's not a perfect 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 gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The intended usage is only implicit from the tool name and simple 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 discloses non-obvious behavior: warm-up for certain timeframes and the meta.freshness field. With no annotations provided, this is valuable. However, it does not mention rate limits or error conditions.

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

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

The description is two sentences, front-loading the purpose and then adding a behavioral detail. No 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 no output schema and a low parameter description coverage, the description is insufficient. It does not explain the response structure, parameter effects, or use cases, leaving significant 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 only 33%, with limit and source having no descriptions. The tool description does not explain any parameter semantics, failing to compensate for the low 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 returns raw OHLCV candle data, which aligns with the name. It is specific about the data type but does not mention alternatives like get_ticker or get_market_structure, so it does not fully distinguish from siblings.

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

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

The description provides no guidance on when to use this tool versus other data retrieval tools. It only describes internal behavior about warm-up, not when the agent should 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explicitly state that this is a read-only operation, nor does it mention permissions, return format, error conditions, or rate limits. The word 'döner' (returns) hints at read behavior, but beyond that no behavioral context is 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 short sentence that is front-loaded and concise. It contains no filler or redundancy, and every word contributes to the core meaning. It is appropriately sized for a simple get 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 that there is no output schema, no annotations, and the description is minimal, the tool lacks essential context. The agent does not know what the return value looks like, how to handle optional parameters, or when this tool is preferable over alternatives. For a tool with 4 parameters and no other documentation, the description is incomplete.

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 implicitly explains the required parameters 'symbol' and 'timeframe' via 'Sembol+timeframe'in', but the optional parameters 'request_id' and 'idempotency_key' are completely unaddressed. The schema provides no descriptions either, leaving these parameters ambiguous.

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

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

The description clearly states the tool returns registered annotations for a given symbol and timeframe ('Sembol+timeframe'in kayıtlı işaretlemelerini döner'). The verb 'döner' (returns) is specific and the resource is clearly identified. It does not explicitly differentiate from sibling tools like annotate_chart or clear_annotations, but the read-only retrieval nature is evident from the verb and 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?

The description provides no guidance on when to use this tool versus alternatives. It does not state whether to use it before or after annotate_chart, nor does it mention any exclusions or prerequisites. The implied use case (retrieving chart annotations) is present but not explicit enough to guide an agent in choosing between this and similar tools.

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

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

With no annotations provided, the description carries the full burden. It discloses useful behavioral traits: VWAP points are limited to avoid context bloat, version fields are explained (meta/data.algo_version vs data.versions), and the liquidity score semantics are specified (sum of zones in equal_levels, active count matches default zones list). This goes beyond the structured schema.

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

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

The description is a compact paragraph of three sentences, front-loaded with the main purpose and followed by important caveats and data semantics. Every sentence adds value, though it is dense and could be slightly better organized for readability.

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 aggregates multiple analysis types with no output schema, so the description must supply return-structure context. It touches on version fields and liquidity zones but does not describe the output structure for structure, order block/FVG, VWAP, or session levels. This is a notable gap for a complex aggregate tool.

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

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

Schema coverage is only 33% (symbol and timeframe described). The description does not compensate for the remaining four parameters (lookback, request_id, idempotency_key, include_mitigated). It only indirectly hints at include_mitigated via 'mitigasyonsuz' but provides no parameter-level detail.

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: a single-call aggregate of all price action analysis including structure, liquidity, order block/FVG, VWAP, and session levels. This distinguishes it from sibling tools that focus on individual components like get_market_structure, get_liquidity_zones, or get_order_blocks.

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 'Tek çağrıda' (in a single call) implies this tool is for when you want a comprehensive summary without invoking multiple separate analysis tools, providing clear contextual guidance. It does not explicitly name alternatives or exclusions, but the aggregate-vs-component distinction is evident from sibling tool names.

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

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

With no annotations available, the description takes on the full responsibility for behavioral disclosure. It transparently covers the default filtering of mitigated zones, the scoring components, and a significant caveat about pre-2.15 historical data semantics. It implies a read-only operation through the 'get' verb but does not explicitly assert non-mutating 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 dense and informative, with each of its four sentences contributing unique details about functionality, parameters, or historical context. While slightly longer than strictly necessary, it contains no filler and is well-structured with a clear progression from output description to caveats.

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

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

Without an output schema, the description does a good job of outlining the main return categories: liquidity zones, sweep/mitigation status, and the liquidity score with its components and bias. It could be slightly more explicit about the exact return format or field names, but it gives enough context for an agent to understand 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 only describes symbol and timeframe, leaving four parameters undocumented (33% coverage). The description compensates for this by thoroughly explaining include_mitigated, but it does not add meaning for lookback, request_id, or idempotency_key, which remain unexplained in both schema and description.

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

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

The description clearly identifies the tool's function: retrieving equal highs/lows liquidity zones with sweep/mitigation status and a futures-based liquidity score. It specifies the resource and the nature of the output, though it does not explicitly contrast it with sibling tools like get_order_blocks or get_market_structure.

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 explains the default behavior (active zones only) and the use of include_mitigated for full history, which implicitly guides when to use different modes. However, it does not explicitly state when to choose this tool over alternatives or list exclusions, leaving the usage context partially 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?

No annotations are provided, so the description carries the full burden. It adds one behavioral detail about the 'meta.algo_version' field, but it does not disclose whether this is a read-only operation, any side effects, permission requirements, or performance implications. This is a significant gap for a non-annotated tool.

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

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

The description is compact, using two sentences with no fluff. The first sentence lists the core components, and the second adds a useful output metadata detail. It is well-structured and front-loaded.

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

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

Given the complexity of market structure analysis and the absence of annotations and output schema, the description is incomplete. It lists high-level components but does not explain how they are represented (e.g., data types, timestamps, prices), how swings are detected, or how to interpret BOS/CHoCH events. Users would need additional context to use the tool effectively.

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

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

The description provides no information about the input parameters. It mentions 'meta.algo_version' in the output, not any parameter semantics. Since schema description coverage is only 40%, the description fails to clarify parameters like 'lookback', 'request_id', or 'idempotency_key'.

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

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

The description clearly identifies the tool's output: swing highs/lows, BOS/CHoCH, trend, and swing classifications (HH/LH/HL/LL). It is specific and distinguishes from sibling tools like get_candles or get_order_blocks, though it lacks an explicit verb in the description (the verb is implied by 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?

There is no guidance on when to use this tool versus alternatives such as get_full_analysis or get_order_blocks. The description only states what the tool returns, not in which situations it should be 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It clearly states 'Salt-okunur, hiçbir emri değiştirmez/iptal etmez' (read-only, does not modify/cancel any orders), which is a key behavioral trait. It also adds context about the source of 'locked' balance and included order types (OCO/stop-loss/limit), enhancing transparency. However, it does not cover all potential behaviors like rate limits or error handling, but the provided info is valuable.

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 dense sentence that front-loads the primary purpose and then adds necessary context in parentheses. It avoids unnecessary fluff and earns its place with the alternative distinction and read-only note. While a bit long due to parentheticals, it remains compact and 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?

The tool is a read-only query with one required parameter, so the description's detail on scope and read-only nature is adequate for basic usage. However, since there is no output schema, it does not describe the return format or any potential error/edge-case behavior. The mention of 'locked' balance adds some context, but overall it leaves gaps about what the response contains.

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 description coverage is 0%, so the description must compensate for parameter explanations, but it provides none. It does not mention 'account_id', 'request_id', or 'idempotency_key' at all, leaving the agent without guidance on how to fill these fields. Since the tool has three parameters, the omission is significant.

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

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

The description opens with a specific verb 'döner' (returns) and resource 'Borsadaki (Binance) GERÇEK açık emirleri' (real open orders on Binance), clearly stating the tool's function. It also explicitly distinguishes itself from the sibling 'get_pending_orders' by clarifying this is not the internal approval queue but actual exchange orders, eliminating 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 explicitly references the alternative tool 'get_pending_orders' and contrasts the two: this tool returns real exchange orders, not the internal approval queue. This directly tells the agent when to use this tool versus the sibling, covering both when and when-not scenarios.

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

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

With no annotations, the description carries full burden and excels: it discloses merging of nearby OBs, that breakers carry mitigated=true, and the important caveat that immutable history may contain records with old semantics (mitigated=false). It also clarifies that not all regions in history are active, which is critical for correct interpretation.

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 front-loaded with the core purpose, then details default behavior, merging, and a caveat. It is slightly long but each sentence contributes value. The '(2.15)' is cryptic but does not derail overall structure. Efficient for the complexity involved.

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

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

Given no output schema and low schema coverage, the description covers the key domain semantics: types, default behavior, merging, and historical quirks. It lacks details on lookback limits and request_id semantics, but for a data retrieval tool, it is reasonably complete for the primary use case.

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

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

Schema description coverage is only 33% (symbol and timeframe). The description adds significant meaning for include_mitigated, explaining its effect on history vs active zones, but it does not clarify lookback, request_id, or idempotency_key. It partially compensates for the low schema coverage but not fully.

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 resource: order blocks (order_block|breaker|mitigation_block) and FVGs after BOS/CHoCH. It distinguishes from siblings like get_market_structure and get_liquidity_zones by specifying the unique output type. The scope (active zones vs full history) is also included, making the tool's purpose very specific.

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 explains parameter usage (default active zones vs include_mitigated=true for full history) but does not explicitly mention when to choose this tool over alternatives like get_market_structure or get_liquidity_zones. It provides clear context for the include_mitigated parameter but lacks explicit when-not-to-use guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It provides useful context: that an awaiting_approval record is created when an alarm order_spec triggers, and that orders do not open automatically (approve_pending_order required). This goes beyond a simple 'lists' statement and clarifies the lifecycle, though it doesn't mention side effects or permission requirements.

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 three sentences, front-loaded with the main purpose, and each sentence adds value: purpose, status filter, and a critical behavioral note. It contains no filler and is appropriately sized for the tool's complexity.

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 core purpose and status filter are clear, the absence of an output schema and lack of explanation for limit, request_id, and idempotency_key leave gaps. The description doesn't mention return format or pagination behavior, which would be helpful for a listing tool. It's adequate but not fully complete.

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

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

The description explains the 'status' parameter by listing its enum values, but the schema has 0% description coverage for the other three parameters (limit, request_id, idempotency_key). Since the description only compensates for one of four parameters, it leaves significant gaps in understanding the full input schema.

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

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

The description starts with 'Onay bekleyen emir kayıtlarını listeler' (lists order records awaiting approval), a specific verb+resource combination that clearly defines the tool's scope. It further distinguishes from sibling tools like get_open_orders by focusing on the approval workflow and enumerating all possible statuses in the filter.

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 use for viewing orders in various approval states, especially pending approval, and notes that approve_pending_order is required for orders to open. However, it does not explicitly contrast with alternatives such as get_open_orders or list_alerts, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses return content (status enum and pipeline health) but does not mention side effects, permissions, latency, or whether pipeline health checks might be expensive. This is minimal for a read operation but lacks 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?

The description is a single compact sentence that front-loads the tool's purpose and the possible readiness values. There is no wasted wording, though it is underspecified in other dimensions.

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 or annotations, the description is responsible for explaining return values and usage context. It partially covers return values by listing readiness states and pipeline health, but leaves pipeline health vague and parameter semantics completely unaddressed. It is a minimal and incomplete description for an agent 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 0% and the description does not mention request_id or idempotency_key. Since the schema provides no descriptions and the description does not compensate, the meaning and purpose of both parameters are entirely unexplained.

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 reports daemon readiness status with enumerated states (starting|migrating|warming_up|ready) and pipeline health. It distinguishes from the sibling tool ping by offering more granular readiness states, though it does not explicitly name any sibling.

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 like ping or other health/status checks. It implies a readiness check but does not state prerequisites, exclusions, or alternative tool comparisons.

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

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

With no annotations, the description carries the burden of disclosing behavior. It explains the 'empty/unlimited default' when not configured, which is useful. However, it does not mention any other behavioral traits such as permissions or error conditions, but for a read-only getter this 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, concise sentence that is front-loaded with the core purpose and includes a note about the default. Every word earns its place and there is no unnecessary verbosity.

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, the description covers the core behavior and default, but it does not describe the response structure or the optional parameters. Given no output schema, the description should provide more detail on what the returned policy looks like, but it is minimally adequate.

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

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

The description does not explain any parameters explicitly. It indirectly refers to account via 'Hesabın' (account's), but request_id and idempotency_key are completely unmentioned. With 0% schema coverage, the description fails to compensate for the 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 verb ('döner' = returns) and resource ('risk politikası' = risk policy), clearly indicating a getter operation. It distinguishes itself from sibling tools like set_risk_policy and override_risk_policy by explicitly returning the current policy.

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 is for reading the current risk policy, which is distinct from the write operations of sibling tools. However, it does not explicitly name alternatives or state when-not to use it, so it misses the top 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?

With no annotations, the description carries the transparency burden. It adds useful context about meta.freshness indicating the staleness of exchangeInfo, and it implies a read-only query by describing returned data. However, it doesn't explicitly state the tool is read-only, discuss error cases, or mention potential network calls, leaving gaps in behavioral disclosure.

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 concise sentences with specific details. It front-loads the core purpose and includes useful filter names and freshness metadata without wasted words.

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

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

For a single-symbol info tool with no output schema, the description adequately explains return contents (filters and status) and the freshness meta field. It does not mention that results are limited to the provided symbol or any error behavior, but these are minor given the tool's simplicity and strong parameter description for the required field.

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

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

Schema description coverage is only 33% (symbol described as 'Spot USDT çifti, örn. BTCUSDT'). The tool description adds no parameter explanation—it lists output filters but does not map them to parameters. request_id and idempotency_key are left undocumented by both schema and description, so the description fails to compensate for the low 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 returns Binance exchangeInfo filters (LOT_SIZE, MIN_NOTIONAL, PRICE_FILTER) and symbol status. The verb 'döner' (returns) plus specific resource and filter types make the purpose unambiguous, and it distinguishes itself from sibling market-data tools by naming exact output components.

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 specify when to use this tool versus alternatives like get_ticker or get_market_structure. It implies use for exchange filter retrieval but offers no explicit context, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It usefully discloses that data may be stale if the WebSocket disconnects and that meta.freshness indicates currency, adding significant context beyond the name.

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

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

The description is two concise sentences, front-loaded with the core action, and contains 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?

For a simple ticker tool with no output schema or annotations, the description adequately covers the key staleness behavior and data source. It does not explicitly list return fields, but the term '24h ticker' implies standard ticker data, making it 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?

Schema coverage is only 33% (only symbol is documented). The description does not explain request_id or idempotency_key, and it fails to compensate for the low schema coverage, leaving critical parameter semantics unaddressed.

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 fetches an instantaneous 24-hour ticker for a symbol from the miniTicker WebSocket. This specific verb+resource construction distinguishes it from sibling tools like get_candles or get_symbol_info.

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 real-time usage via the miniTicker WS source but provides no explicit guidance on when to use this tool versus alternatives. No exclusions or alternative tool names are mentioned.

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

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

With no annotations, the description carries the transparency burden. It discloses the calculation methodology and use of fresh prices, but does not mention side effects, authentication, or error conditions. Since it's a 'get' operation, safety is inferred but not explicitly stated.

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

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

The description is a single, information-dense sentence that front-loads the main purpose and then adds relevant detail. No empty phrases 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?

Without an output schema, the description must explain the response. It gives a high-level breakdown (symbol and account level) but omits specific fields, units, or error behavior. The detail provided is adequate for understanding the tool's purpose but not exhaustive.

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 lists two optional string parameters (request_id, idempotency_key) with no descriptions, and the tool description does not mention them. Schema coverage is 0%, so the description fails to compensate, though these appear to be generic metadata parameters.

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 this tool returns total exposure across all accounts, broken down by symbol (open order notional + base balance using daemon's fresh price) and by account summary. This specific verb+resource+scope distinguishes it from siblings like get_account_balance or get_open_orders.

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 aggregate exposure is needed, but it does not explicitly mention alternatives or exclusions. No sibling tools are referenced, so the guidance is only implicit.

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

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

Given no annotations, the description carries the full burden. It discloses the persistence behavior (records don't vanish when agent is offline) and mentions optional filter and pagination, but does not address whether the operation is read-only, requires authentication, or details the response format.

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

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

The description is one compact sentence that front-loads the main purpose and includes two key features (optional filter and pagination), with no redundant 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?

For a 5-parameter tool with no output schema and no annotations, the description is incomplete. It lacks response structure, semantics for request_id and idempotency_key, pagination behavior, and any error handling or edge cases.

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

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

With 0% schema description coverage, the description must explain parameters. It references an alert_id filter and pagination, which maps to alert_id and limit/cursor, but leaves request_id and idempotency_key entirely unmentioned, and does not give parameter names or value constraints beyond what the schema types provide.

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 'döner' (returns) with a specific resource ('kalıcı tetiklenme kayıtları' – persistent trigger records), clearly distinguishing it from tools like list_alerts. It also adds the persistence qualifier, which states the records are kept even when the agent is offline.

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 retrieving triggered alert records, particularly those that occurred during agent downtime, but it does not explicitly state when to prefer this over list_alerts or other alert-related tools. No exclusions or alternative 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?

With no annotations provided, the description carries the full burden. It explicitly states 'Salt-okunur, hiçbir emri değiştirmez' (read-only, does not modify any order) and explains the empty-result semantics, adding meaningful behavioral context beyond the tool 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 two dense sentences, front-loaded with the core function and followed by read-only and empty-result notes. Every sentence earns its place with no 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?

The description covers all key contextual aspects: scope (all real accounts), filter criteria (dust-above, no open SELL order including SL/TP/OCO), read-only nature, and empty-result interpretation. For a read-only query with no output schema, this 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 input schema lists two optional generic parameters (request_id, idempotency_key) with 0% schema description coverage. The description does not mention or explain these parameters at all, failing to compensate for the low coverage, even though their names suggest common infrastructure purposes.

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 'finds dust-above base asset balances without an open SELL order (including SL/TP/OCO) across all real accounts', using a specific verb and resource. It also answers a concrete question ('which position is left unprotected'), distinguishing it from siblings like get_open_orders or get_total_exposure.

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 usage context by specifying it answers a single-call question about unprotected positions. It also notes the tool is read-only, which helps differentiate it from mutating siblings, though it does not explicitly name alternatives 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?

Without annotations, the description carries the burden of disclosing behavior. It does state that returned summaries contain no secrets and explains what the credentials_configured/read_only fields indicate, which is useful. However, it does not explicitly say the operation is read-only or side-effect-free, leaving a gap in safety characterization.

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 concise sentences, front-loaded with the primary action. It avoids redundancy and every sentence adds value, making it 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 list tool with no output schema, the description covers the main output fields and purpose. However, it omits parameter semantics and provides no usage context relative to sibling tools, making it minimally complete for a tool with these complexities.

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 description coverage is 0%, and the description does not mention request_id or idempotency_key at all. Since the schema provides no descriptions for these parameters, the lack of compensation in the description is a significant gap.

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

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

The description uses a specific verb and resource: 'Hesapları ... listeler' (lists accounts). It also clarifies the output nature (summaries without secrets) and defines the meaning of fields, distinguishing it from account balance, add, or remove 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?

No guidance on when to use this tool versus alternatives. It does not mention that this should be used for listing accounts as opposed to get_account_balance or add_account. The description only states what the tool does, not when it is appropriate relative to other tools.

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

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

No annotations are provided, so the description carries full burden. It discloses that it lists alerts with statuses, but omits behavioral details such as authentication requirements, pagination, whether both armed and triggered are always included, or any side effects, leaving the agent uncertain about the operation's nature.

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 a clear verb-object structure, front-loaded with the verb. Every word earns its place, with no fluff 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?

Given the absence of annotations and output schema, and unexplained parameters, the description is incomplete. It does not describe the response format, result ordering, or the purpose of request_id and idempotency_key, leaving important gaps 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?

The input schema has two parameters (request_id, idempotency_key) with no descriptions and 0% schema description coverage. The description does not mention these parameters or their purpose, so it adds no semantic value beyond the schema.

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

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

The description uses a specific verb 'listeler' (lists) with resource 'all alert definitions' and includes status scope 'with statuses (armed/triggered)', clearly distinguishing it from create/delete alerts and from get_triggered_alerts which likely returns only triggered alerts.

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 provide explicit guidance on when to use this tool versus alternatives like get_triggered_alerts. It implies a general list-all use case but lacks any exclusions or comparisons to 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?

With no annotations, the description carries full burden and does so impressively. It discloses atomicity, one-time scope, audit logging of the required reason, and idempotent retry behavior (same override, no secondary). These are critical behavioral traits beyond the basic schema.

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

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

Four concise sentences, each delivering essential information with no redundancy. The first sentence carries the core purpose, followed by constraints, side effects, and idempotency.

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

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

The description covers purpose, scope, constraints, audit trail, and idempotency. Given no output schema and moderate complexity, it is mostly complete, but lacks return value or error behavior details which could be inferred from the tool's nature.

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

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

Schema coverage is only 17% (expires_at only), so the description must compensate. It adds meaning for reason (required, audit-logged) and idempotency_key (retries bind to same override), but leaves account_id and request_id semantics unexplained, creating a partial gap.

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

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

The description clearly states the tool creates a one-time, atomic risk policy exception for the next order, allowing override of user-defined caps only. This distinguishes it from siblings like set_risk_policy (persistent policy) and place_order (execution).

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 explicitly says it only allows overriding user-defined caps for a single order and never bypasses basic accuracy checks, making the intended use case clear. It doesn't name alternatives but the sibling context implies set_risk_policy for persistent changes, so the guidance is nearly complete.

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

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

With no annotations, the description carries the full burden. It discloses that this is a non-mutating check (via 'kontrol' = check) and that 'ready' is not required. However, it does not mention what the response looks like, whether errors are thrown when the daemon is unreachable, or any side effects like network calls. This leaves some behavioral ambiguity.

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

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

The description is two short sentences, front-loaded with the primary purpose and an important usage caveat. Every word earns its place, and it is appropriately sized for a simple health-check 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 ping tool with minimal parameters, the description is mostly adequate: it states what the tool does and a key usage condition. However, the absence of any return value or failure indication is a notable gap, especially since there is no output schema to fill that in. Overall, it is acceptable 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?

The schema has two optional parameters: request_id (described as trace ID) and idempotency_key (no description). The tool description mentions neither parameter, so it adds no meaning beyond the schema. With only 50% schema coverage, the description should have at least clarified idempotency_key's purpose or stated that both are optional tracing aids, but it did not.

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 and resource: 'connection and liveness check with daemon.' It distinguishes the tool from all trading-related siblings, as no other tool serves a health-check purpose. The note about 'ready' not required further clarifies its unique role.

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 usage context by stating that no 'ready' is required for the tool call, which tells the agent when it can be used (e.g., before the system is fully ready). However, it does not explicitly name alternatives like get_readiness, so it falls short of a full when/when-not 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?

With no annotations provided, the description carries the full burden. It discloses that one order cancellation triggers the other, that it uses a single orderList/oco call, and that stop_limit_price must be lower than stop_price. It does not discuss potential failure modes, permissions, or partial-fill behavior, but the core behavioral traits are clearly stated.

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

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

The description is compact and front-loaded, explaining the purpose and key constraints in a few tight sentences. Every sentence adds value—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?

Given the complexity of a 9-parameter OCO order and no output schema, the description covers the essential mechanics, the rationale for using the tool, and parameter relationships. It does not describe response format or error conditions, but these are less critical for correct invocation.

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

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

The description adds significant meaning for price-related parameters (price=TP, stop_price=stop trigger, stop_limit_price=stop filled limit) and the constraint that stop_limit_price < stop_price. However, it leaves account_id, idempotency_key, and request_id unexplained, and schema coverage is only 56%, so the description does not fully compensate for all parameters.

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

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

The description clearly identifies the tool as placing a spot OCO order with take-profit (LIMIT) and stop-loss-limit (STOP_LOSS_LIMIT) in a single order list. It distinguishes itself from alternative approaches by explaining the 'true OCO' mechanism and why separate SL+TP orders are impossible on this exchange.

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 explains the specific use case: when both a take-profit and stop-loss are needed for the same position, and why separate orders would conflict (stealing balance). It implies this tool should be used instead of placing separate SL+TP orders, though it does not explicitly mention alternative sibling tools like place_order for single-order scenarios.

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

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

With no annotations, the description carries the full burden and delivers: STOP_LOSS_LIMIT trigger semantics, idempotency-key guarantee against duplicate orders, network-timeout reconciliation from Binance, and constant validation checks. This goes well beyond schema and covers key 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?

Four sentences are dense with valuable information, starting with core action then expanding into critical behaviors. No filler, though the sentence about validation checks is somewhat vague and could be trimmed or made more specific.

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?

Tool is complex with 9 params, 3 order types, and idempotency, and there is no output schema or annotations. Description covers execution semantics and failure handling, but it does not describe what the caller receives on success/failure (e.g., order ID, status, error format). This missing return-contract information is a notable 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 only 44%, but the description compensates by explaining order_type values, the price/stop_price relationship for STOP_LOSS_LIMIT, and the semantic role of idempotency_key. It also clarifies that quantity is in base asset, adding significant meaning beyond the bare enum/type definitions.

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

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

Description opens with 'Tek hesapta doğrudan emir gönderir' (sends direct order on a single account), clearly identifying the action and resource. It lists supported order types and quantity semantics. It does not explicitly name sibling tools like place_oco_order to differentiate, so not a 5.

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

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

The description explains STOP_LOSS_LIMIT as spot stop protection and notes it works even when daemon is off, which implies a use case for that order type. However, it gives no explicit when-to-use vs MARKET/LIMIT or vs place_oco_order, and no prerequisites such as account or balance 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 discloses the core behavioral consequence ('order does not open') but does not cover side effects, reversibility, or prerequisites. With no annotations, the description carries the full burden, and while it adds some value, it 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 concise sentence with no extraneous words. It efficiently conveys the core action and a clarifying consequence.

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 no annotations, no output schema, and four parameters with zero explanation. The description only addresses the basic rejection action, leaving parameter purposes and operational context unaddressed, making it inadequate for reliable invocation.

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

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

The description mentions no parameters. The input schema lists four parameters (reason, order_id, request_id, idempotency_key) with 0% schema description coverage, so the description must compensate but completely fails to explain any 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 explicitly states 'rejects the pending order' (Onay bekleyen emri reddeder) with the clarification that the order will not open (emir açılmaz). This clearly defines the tool's function, distinguishes it from approve_pending_order, and uses a specific verb and resource.

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 used when rejecting pending orders, but it does not provide explicit context, exclusions, or alternatives. Sibling tools like approve_pending_order are not referenced, so the usage guidance is merely inferential 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?

With no annotations, the description carries the transparency burden. It discloses that the operation removes both the account and its credential records, and that the action is written to the audit log. However, it does not mention permissions, reversibility, or potential side effects beyond the two stated facts.

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 delivers essential information (what is removed and the audit log side effect) without redundancy. It is front-loaded and 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 destructive tool with no annotations and no output schema, the description is too sparse. It does not address whether the removal is reversible, what happens to dependent data, or any preconditions. The audit log detail helps but does not compensate for the missing critical 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 description does not reference any of the three parameters (account_id, request_id, idempotency_key). Schema description coverage is 0%, and the description fails to clarify the purpose or format of any parameter, leaving the agent with no additional meaning beyond the schema.

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

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

The description clearly states the action ('kaldırır' = removes) and the resource ('Hesabı ve bağlı credential kayıtlarını' = the account and associated credential records). This is specific and distinguishes it from siblings like add_account or list_accounts.

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, nor any exclusions or prerequisites. It simply states what the tool does without context.

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

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

No annotations are provided, so the description carries the full transparency burden. It discloses key output fields (data_stale, symbol_valid, matched_filters, signal_summary) and warns that data_stale=false doesn't guarantee tradability, requiring symbol_valid. It also clarifies the filter AST restriction (not SQL), adding important contextual 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 paragraph of three sentences, front-loaded with the main action and followed by output details and a caveat. Every sentence adds value, though it's slightly dense with Turkish terminology and the '2.16' reference.

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

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

Given no output schema, the description explains important return fields and the tradability caveat. However, it lacks details on pagination, sorting, timeframes, and the exact AST node structure beyond filter types, leaving some gaps for a tool with this 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 coverage is only 25%, with only 'filters' having a description. The description enriches the filters parameter by listing allowed filter types and nesting via and/or, but it doesn't explain limit, cursor, combine, sort_by, timeframe, or the idempotency/request fields, so most parameters remain unclear despite defaults/enums.

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 it 'scans the symbol universe' using an allowlisted filter AST, with a specific verb and resource. It distinguishes itself from sibling tools by listing available filter types and noting it's not free SQL, making its 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 screening the symbol universe with structured filters, but it doesn't explicitly mention when to prefer this over alternatives or when not to use it. The context is clear from the scanning description, yet 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly discloses strict cap enforcement (no tolerance, final value must be <= cap after rounding), patch preservation semantics, and the explicit clearing mechanism. These are critical behavioral traits beyond the schema, though it does not address permissions, rate limits, or error behavior.

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

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

The description is three dense sentences covering purpose, defaults, strict caps, and patch/clear semantics with no filler. It is well-structured and front-loaded, though slightly lengthy in Turkish.

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 9-parameter tool with no output schema and no annotations, the description covers the core policy fields and clearing behavior but omits mention of account_id, request_id, and idempotency_key. It also does not describe the return value or error cases, leaving some ambiguity for correct invocation.

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

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

The description adds meaning for the three primary policy fields and the three clear booleans (explaining strict caps and clearing). However, schema description coverage is only 33%, and the description does not explain account_id, request_id, or idempotency_key, leaving these parameters undocumented and not fully compensating for the coverage gap.

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

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

The description clearly states the tool's purpose with the specific verb 'tanımlar' (defines/sets) and resource 'risk policy' for an account, listing the affected fields (max_notional_per_order, max_aggregate_exposure, allowed_symbols). It distinguishes itself from sibling tools like get_risk_policy (read) and override_risk_policy by detailing patch semantics and explicit clear flags.

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 usage context: the default state is empty/unlimited, values not sent in a patch are preserved, and clearing only happens via explicit booleans. This implicitly guides when to use this tool for partial updates. However, it does not explicitly mention alternatives like override_risk_policy 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.