mcp-binance-futures

by Muvon

Overview Schema Related Servers Score Discussions

Python

Remote

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Most tools have distinct purposes targeting specific futures trading operations like orders, positions, account info, and market data. However, some overlap exists between get_order and get_order_history (specific vs. recent orders) and between get_ticker and get_symbol_info (price stats vs. trading rules), though descriptions help clarify their differences.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, such as get_account_summary, cancel_order, set_leverage, and adjust_isolated_margin. All tools use snake_case with clear, descriptive verbs, making the set predictable and easy to navigate.
Tool Count3/5
With 23 tools, the count is borderline high for a single server, though it covers a comprehensive range of futures trading operations. It feels slightly heavy but is justifiable given the complexity of the domain, including orders, positions, account management, and market data.
Completeness5/5
The tool set provides complete coverage for Binance Futures trading, including full CRUD/lifecycle operations for orders (place, modify, cancel, get), positions (get, adjust margin), account settings (leverage, margin type, position mode), and market data (klines, ticker, order book). No obvious gaps are present for core trading workflows.
Average 3.7/5 across 23 of 23 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 states 'Get the most recent public trades', which implies a read-only, non-destructive operation, but doesn't mention rate limits, authentication requirements, pagination, or response format. This leaves significant gaps in understanding how the tool behaves in practice.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core functionality, making it easy to parse quickly, which is ideal for conciseness in tool selection.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (simple read operation with 2 parameters), 100% schema coverage, and the presence of an output schema (which handles return values), the description is minimally adequate. However, it lacks behavioral context like rate limits or authentication needs, which could be important for a trading API tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear documentation for both parameters ('symbol' and 'limit'), including defaults and constraints. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for adequate but unenhanced coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('most recent public trades for a symbol'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'get_trade_history' or 'get_ticker', which could cause confusion about when to use each one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'get_trade_history' or 'get_order_history'. It mentions 'public trades', which implies a read-only operation, but doesn't specify use cases, prerequisites, or exclusions, leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 implies a read-only operation ('Get'), but does not specify if it requires authentication, rate limits, error conditions, or the format of returned data. The description lacks details on what 'trading rules' entail beyond the listed examples, leaving gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get trading rules for a symbol') and provides illustrative examples. There is no wasted verbiage or redundancy, making it highly concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no nested objects) and the presence of an output schema (which likely covers return values), the description is minimally adequate. However, with no annotations and incomplete behavioral transparency, it lacks depth for a tool that might involve financial data retrieval. It meets basic needs but could benefit from more context on usage and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'symbol' parameter clearly documented as 'Trading pair, e.g. 'BTCUSDT''. The description adds no additional meaning beyond this, as it does not explain parameter usage, constraints, or examples. With high schema coverage, the baseline score of 3 is appropriate, as the schema adequately handles parameter semantics without extra description input.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get trading rules for a symbol' with specific examples like 'tick size, lot size, min notional, max leverage, etc.' It uses a specific verb ('Get') and resource ('trading rules for a symbol'), but does not explicitly differentiate from sibling tools like 'get_ticker' or 'get_order_book', which might also provide symbol-related information but for different data types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or specific contexts for usage. For example, it does not clarify if this is for pre-trade checks or general information retrieval, nor does it reference sibling tools that might overlap in functionality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but lacks behavioral details. It mentions returns but doesn't disclose if this is a high-risk mutation, requires specific account permissions, has rate limits, or affects open positions. 'Set leverage' implies a write operation, but safety and side effects are undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—it states the action, target, and return values directly. It's appropriately sized and front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a financial mutation with no annotations) and an output schema (which covers return values), the description is minimal but functional. It states the purpose and returns, but lacks critical context like risk implications or usage guidelines, making it adequate but incomplete for safe agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no parameter-specific semantics beyond implying 'symbol' and 'leverage' are used, which the schema already covers with descriptions and constraints like '1–125'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Set leverage') and target resource ('for a symbol'), and mentions the return values. It specifies the verb and resource but doesn't differentiate from siblings like 'set_margin_type' or 'set_position_mode' that also configure trading parameters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'set_margin_type' or 'set_position_mode', nor any prerequisites or context for leverage changes. The description only states what it does, not when it's appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 implies a read-only operation by using 'Get', but does not specify authentication needs, rate limits, error conditions, or the format of the output. For a financial tool, this lack of detail on security and performance is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key action ('Get account-level summary') and lists specific metrics without any wasted words. It is appropriately sized for a tool with no parameters and clear output focus.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple read operation with no parameters) and the presence of an output schema, the description is adequate but minimal. It covers the purpose and key metrics but lacks behavioral context like authentication or error handling, which is partially mitigated by the output schema handling return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there is no need for parameter details in the description. The description appropriately focuses on the tool's purpose without redundant parameter information, aligning with the baseline for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 a specific verb ('Get') and resource ('account-level summary'), listing key metrics like total balance, unrealized PnL, margin ratio, and positions count. However, it does not explicitly differentiate from sibling tools like 'get_balance' or 'get_positions', which might provide overlapping or related data, leaving some ambiguity about 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.
Usage Guidelines2/5
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. With siblings such as 'get_balance' and 'get_positions' that might offer similar or complementary information, there is no indication of context, prerequisites, or exclusions to help an AI agent choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states this is a 'Get' operation, implying it's read-only, but doesn't confirm if it requires authentication, has rate limits, or describes the output format. While the presence of an output schema helps, the description itself lacks critical behavioral context for a tool in a financial trading environment.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—a single sentence that directly states the tool's purpose without any wasted words. It's front-loaded with the core action and result, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema provided), the description is minimally adequate. However, in a trading context with siblings like 'get_positions', more context on usage or differentiation would be beneficial. The output schema handles return values, so the description doesn't need to explain those, but it could better address the tool's role within the server.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, and it appropriately doesn't mention any. A baseline of 4 is given since no parameter information is required, and the description doesn't introduce confusion about inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 a specific verb ('Get') and resource ('current position mode'), and identifies the two possible modes (Hedge Mode or One-way Mode). However, it doesn't explicitly differentiate this tool from its sibling 'get_positions', which might also provide position-related information, leaving room for ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. With siblings like 'get_positions' and 'get_account_summary' that might overlap in context, there's no indication of when this specific tool is appropriate or what distinguishes it from other position or account-related queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral details. It doesn't disclose authentication needs, rate limits, pagination, or response format. While 'Get' implies read-only, the lack of annotations means critical operational context is missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose, making it easy to scan and understand quickly without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity, 100% schema coverage, and presence of an output schema, the description is reasonably complete. It specifies 'personal' and 'fills', which adds useful context, though more behavioral details would improve completeness for a financial tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter semantics beyond the schema, which has 100% coverage with clear descriptions for 'symbol' and 'limit'. Baseline is 3 since the schema fully documents parameters, but the description doesn't enhance understanding with examples or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('personal trade execution history for a symbol'), specifying it retrieves fills rather than orders. However, it doesn't explicitly differentiate from sibling tools like 'get_order_history' or 'get_recent_trades', which could cause confusion about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_order_history' or 'get_recent_trades'. The description mentions 'personal' and 'fills', but doesn't clarify exclusions or prerequisites, leaving usage context implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks critical behavioral details. It doesn't disclose whether this is a read-only operation, authentication requirements, rate limits, pagination behavior, or error conditions. The phrase 'Get recent' hints at read-only but isn't explicit, leaving gaps in safety and operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part ('Get recent order history for a symbol (all statuses)') contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (historical data retrieval), 100% schema coverage, and presence of an output schema, the description is minimally adequate. However, it lacks context on authentication, rate limits, or data recency, which are important for an order history tool in a trading environment. The output schema reduces need to explain returns, but behavioral gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear documentation for both parameters (symbol and limit). The description adds no additional parameter semantics beyond what's in the schema, such as format examples for 'recent' or status filtering details. Baseline 3 is appropriate as the schema adequately covers parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('recent order history for a symbol'), specifying scope with 'all statuses'. It distinguishes from siblings like get_open_orders (which filters by open status) and get_order (which retrieves a single order), though it doesn't explicitly name these alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by mentioning 'all statuses', suggesting this tool is for comprehensive historical retrieval rather than filtered views. However, it doesn't explicitly state when to use it versus alternatives like get_open_orders or get_order, nor does it mention prerequisites such as authentication or rate limits.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the return format ('Returns a merged dict with...') which adds some behavioral context, but it doesn't disclose critical traits like whether this is a read-only operation, latency expectations, rate limits, authentication needs, or error handling. For a financial data tool with no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured. The first sentence clearly states the purpose, and the second sentence efficiently lists the return fields without unnecessary details. Every sentence earns its place, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, financial data retrieval), the description is reasonably complete. It specifies what data is returned, and since an output schema exists (implied by context signals), it doesn't need to explain return values in detail. However, it lacks context on behavioral aspects like safety or performance, which would be helpful given no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description doesn't explicitly discuss parameters, but the input schema has 100% coverage with one parameter ('symbol') fully documented. Since schema_description_coverage is high (>80%), the baseline is 3. The description adds value by implying the parameter's purpose through the tool's function ('for a symbol'), slightly enhancing understanding beyond the schema's technical description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get latest price, 24 h stats, and mark/index prices for a symbol.' It specifies the verb ('Get') and resource ('price, 24 h stats, and mark/index prices'), making the function unambiguous. However, it doesn't explicitly differentiate from siblings like get_symbol_info or get_recent_trades, which might provide overlapping data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate compared to siblings like get_symbol_info (which might provide static symbol details) or get_recent_trades (which might provide trade history). There's no context about prerequisites, timing, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states it's a read operation ('Get details'), but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or what happens if multiple identifiers are provided. For a financial API tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which means the description doesn't need to explain return values) and 100% schema coverage, the description is reasonably complete for a simple lookup tool. However, the lack of behavioral context (especially for a financial API) prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description mentions orderId and clientOrderId but doesn't add meaning beyond what the schema provides about these identifiers. The baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get details') and resource ('specific order'), specifying it retrieves order information by identifiers. It distinguishes from siblings like get_open_orders (which lists multiple orders) and get_order_history (which shows historical orders), but doesn't explicitly name these alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need details for a specific order using orderId or clientOrderId, but doesn't explicitly state when to use this versus alternatives like get_open_orders or get_order_history. No guidance on prerequisites or exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 states the tool returns a list with specific fields (e.g., asset, balance), which adds value by detailing the output structure. However, it lacks information on critical behaviors such as authentication requirements, rate limits, error handling, or whether the data is real-time or cached, leaving gaps in operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured, consisting of two sentences that efficiently convey the tool's purpose and output. The first sentence states what it does, and the second details the return values, with no wasted words or redundancy. This front-loaded approach makes it easy for an agent to quickly understand the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters) and the presence of an output schema (which likely defines the return structure), the description is reasonably complete. It specifies the scope ('non-zero balance') and lists return fields, adding context beyond the schema. However, it could improve by mentioning authentication or data freshness, but the output schema reduces the need for extensive return value explanation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so the schema fully documents the lack of inputs. The description adds no parameter information, which is appropriate here. Since there are no parameters to explain, the description's focus on output is sufficient, earning a baseline score of 4 for not needing to compensate for any schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get futures wallet balances for all assets with non-zero balance.' It specifies the verb ('Get'), resource ('futures wallet balances'), and scope ('all assets with non-zero balance'). However, it does not explicitly distinguish itself from sibling tools like 'get_account_summary', which might provide overlapping or related financial data, leaving room for ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as authentication or account setup, or specify contexts like checking balances before trading. With siblings like 'get_account_summary' that might include balance information, the lack of differentiation leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return format comprehensively and mentions special handling for algo orders ('_isAlgo': True), which is valuable behavioral context. However, it doesn't mention rate limits, authentication requirements, error conditions, or whether this is a read-only operation (though 'get' implies reading). The description doesn't contradict any annotations since none exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by return format details. The two sentences earn their place by providing essential information. However, the long list of return fields could have been summarized more concisely, and the algo order note feels slightly tacked on rather than integrated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (though not shown here), the description doesn't need to explain return values in detail, yet it provides a comprehensive list anyway. With 100% schema coverage and no annotations, the description adds good value through return format disclosure and algo order handling. For a read operation with good schema documentation, this is reasonably complete, though it could mention authentication or rate limits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. The baseline of 3 is appropriate when the schema does all the parameter documentation work, though the description could have explained why 'source' parameter matters for the return format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get open orders') and resource ('for a symbol'), making the purpose immediately understandable. It distinguishes from siblings like 'get_order' (single order) and 'get_order_history' (historical orders) by focusing on current open orders. However, it doesn't explicitly contrast with 'cancel_all_orders' or 'modify_order' which also operate on open orders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the return format details and algo order note, but doesn't explicitly state when to use this tool versus alternatives. No guidance is provided about when to use 'get_open_orders' versus 'get_order' (for specific order) or 'get_order_history' (for completed orders), though the 'open orders' focus provides some implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions modifying 'existing open LIMIT order' which implies mutation, but doesn't disclose critical behavioral traits: whether this requires specific permissions, rate limits, if modifications are atomic or partial, error conditions, or what happens if only price or quantity is provided. The HTTP endpoint reference adds some context but insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence efficiently conveys core purpose with no wasted words. The HTTP endpoint in parentheses provides useful technical context without disrupting readability. Perfectly front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 6 parameters, no annotations, but with output schema (which handles return values), the description is minimally adequate. It covers the what and scope but lacks behavioral context about permissions, side effects, error handling, and parameter dependencies that would be crucial for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds minimal value beyond schema by emphasizing 'price or quantity' modification and specifying 'open LIMIT order' context, but doesn't explain parameter interactions (e.g., that order_id or client_order_id is needed to identify the order, or that price/quantity can be null for partial updates). Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Modify price or quantity'), target resource ('existing open LIMIT order'), and scope ('open LIMIT order') with the HTTP method context. It distinguishes from siblings like 'place_order' (create) and 'cancel_order' (delete) by focusing on modification of existing orders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for modifying existing open limit orders, but doesn't explicitly state when NOT to use it (e.g., for market orders, closed orders, or creating new orders) or mention specific alternatives like 'cancel_order' + 'place_order' for more complex modifications. The context is clear but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 describes a read operation ('Get') but doesn't mention whether this requires authentication, has rate limits, returns real-time or cached data, or what happens on errors. For a financial data tool with zero annotation coverage, this leaves significant behavioral gaps that could affect agent reliability.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get leverage brackets for a symbol') and adds necessary detail ('max leverage per notional tier with maintenance margin rates') without any wasted words. Every part of the sentence contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, read-only operation) and the presence of an output schema (which handles return values), the description is reasonably complete. It clearly states what the tool does and what data it provides. However, the lack of annotations and behavioral context (e.g., authentication needs, rate limits) prevents a perfect score, as these are important for reliable agent operation in a trading context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'symbol' well-documented in the schema as 'Trading pair, e.g. 'BTCUSDT''. The description adds no additional parameter semantics beyond what the schema provides, such as format constraints or examples. Given the high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get leverage brackets') and resource ('for a symbol'), with precise details about what information is retrieved ('max leverage per notional tier with maintenance margin rates'). It effectively distinguishes this from sibling tools like get_symbol_info or get_account_summary by focusing specifically on leverage bracket data rather than general symbol information or account details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'for a symbol' and mentioning 'max leverage per notional tier with maintenance margin rates,' suggesting this tool is used when leverage bracket information is needed. However, it doesn't explicitly state when to use this tool versus alternatives like get_symbol_info (which might include some leverage data) or set_leverage (which modifies leverage), nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 clearly describes the return format (list of dicts with specific fields) which is valuable, but doesn't mention rate limits, authentication requirements, data freshness, or error conditions. The description adds meaningful output information but leaves other behavioral aspects unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences: one stating the purpose and one detailing the return format. Every word earns its place, and the most important information (what the tool does) is front-loaded. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (though not shown here), the description doesn't need to explain return values, and it does provide the return structure anyway. With 100% schema coverage and clear purpose, it's mostly complete for a data retrieval tool, though additional behavioral context (like rate limits) would be helpful since no annotations are provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the input schema already fully documents all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation but doesn't provide additional semantic context about how parameters interact or affect results.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get OHLCV candlestick data') and resource ('for a symbol'), distinguishing it from sibling tools like get_ticker or get_recent_trades that provide different market data. It precisely identifies the type of financial data being retrieved.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving historical price data in candlestick format, but provides no explicit guidance on when to choose this tool over alternatives like get_ticker (current price) or get_recent_trades (trade-level data). It doesn't mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return format (lists of [price, qty]) which is valuable behavioral information, but doesn't mention rate limits, authentication requirements, or whether this is real-time or cached data. It adds some context beyond basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste. First sentence states purpose, second sentence provides crucial return format information. Perfectly front-loaded and appropriately sized for this tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which handles return values), 100% parameter schema coverage, and no annotations, the description provides good context about what the tool returns. However, for a financial data tool with no annotations, it could benefit from mentioning rate limits or data freshness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., doesn't explain symbol format beyond 'BTCUSDT' or limit implications). Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'order book bids and asks for a symbol', specifying it returns top bids and asks. It distinguishes from siblings like get_ticker (price only) or get_recent_trades (executed trades) by focusing on order book depth.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving order book data, but doesn't explicitly state when to use this versus alternatives like get_ticker (for last price) or get_recent_trades (for executed trades). No guidance on prerequisites or exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that cancellation applies to 'open orders' and mentions routing to 'Algo API' for conditional orders, which adds useful behavioral context. However, it doesn't mention authentication requirements, rate limits, error conditions, or what happens to partially filled orders.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. First sentence states core purpose, second provides crucial conditional logic. Perfectly front-loaded with essential information followed by important nuance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a mutation tool with no annotations but with output schema (which handles return values), the description covers the essential purpose and conditional routing logic well. It could be more complete by mentioning authentication or error handling, but for a trading API tool with good schema coverage, it's reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'orderId or clientOrderId' and provides context for 'is_algo' parameter, but doesn't explain parameter interactions or provide additional semantic meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Cancel a single open order') and identifies the resource ('by orderId or clientOrderId'). It distinguishes from sibling 'cancel_all_orders' by specifying 'single' and from 'modify_order' by focusing on cancellation rather than modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use 'is_algo=True' (for conditional orders from get_open_orders with '_isAlgo': True). It doesn't explicitly state when NOT to use this tool versus alternatives like 'cancel_all_orders' or 'modify_order', but the 'single open order' scope implies differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the prerequisite condition (isolated margin mode with open position) which is valuable behavioral context. However, it doesn't disclose other important traits like authentication requirements, rate limits, potential side effects on liquidation risk, or confirmation of success/failure. The description adds some context but leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise with only two sentences that each earn their place. The first sentence states the core purpose, the second provides critical usage constraints. No wasted words, perfectly front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a financial trading tool with mutation capability (margin adjustment) and no annotations, the description does well by stating the prerequisite condition. However, with an output schema existing, it doesn't need to explain return values. The main gap is lack of disclosure about authentication, rate limits, or risk implications, which would be valuable for a margin adjustment operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain margin calculation, amount units, or position_side implications). Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Add or remove margin') on a specific resource ('isolated position'), distinguishing it from all sibling tools which focus on orders, account info, or other trading operations. It precisely identifies the tool's unique function in margin management.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'Only valid when the symbol is in ISOLATED margin mode with an open position.' This provides clear prerequisites and context for usage, distinguishing it from tools like set_margin_type (which changes margin mode) or get_positions (which retrieves position info).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 the tool performs cancellations in parallel for efficiency, which is valuable behavioral context. However, it doesn't mention potential risks (e.g., irreversible actions), rate limits, authentication requirements, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with only two sentences, both of which add essential information. The first sentence states the core purpose, and the second provides crucial parameter context with zero wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a potentially destructive trading operation with no annotations but with a complete input schema and output schema available, the description covers the essential purpose and parameter behavior well. However, it could benefit from more explicit warnings about the irreversible nature of order cancellations in a trading context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context about the 'source' parameter's default value ('all') and clarifies that it cancels both regular and algo orders in parallel when using 'all'. Since schema description coverage is 100%, the baseline is 3, but the description provides additional operational insight beyond the schema's enum descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Cancel all open orders') and resource ('for a symbol'), distinguishing it from the sibling 'cancel_order' tool which handles individual orders. It precisely defines the scope of the operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use this tool (to cancel all open orders for a symbol) and mentions the 'source' parameter options, but it doesn't explicitly state when NOT to use it or compare it to alternatives like 'cancel_order' for single-order cancellation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that it returns current data for open positions with non-zero size, which is useful behavioral context. However, it does not mention potential rate limits, authentication requirements, error conditions, or whether the data is real-time or cached, leaving gaps for a tool that likely queries live trading data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by a concise list of returned fields. Every sentence earns its place by providing essential information without redundancy, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (retrieving open positions), no annotations, and the presence of an output schema (implied by context signals), the description is fairly complete. It specifies the scope ('non-zero size') and lists returned fields, but could benefit from more behavioral context like data freshness or error handling, though the output schema may cover return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'symbol' well-documented in the schema. The description does not add parameter-specific details beyond what the schema provides, but since there is only one optional parameter and schema coverage is high, the baseline is strong. The description's mention of filtering aligns with the schema but doesn't enhance it significantly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('current open positions') with specific scope ('non-zero size'), distinguishing it from siblings like get_account_summary or get_balance. It explicitly lists the data fields returned per position, making the purpose highly specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving open trading positions, with context from the parameter description suggesting filtering by symbol. However, it does not explicitly state when to use this tool versus alternatives like get_account_summary or get_open_orders, nor does it provide exclusions or prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a critical behavioral constraint (cannot change with positions/orders), which is valuable. However, it doesn't mention other potential traits like required permissions, rate limits, idempotency, or what happens on success/failure. For a mutation tool with zero annotation coverage, this leaves gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured: a clear purpose statement followed by a critical note. Both sentences earn their place—the first defines the action, the second provides essential usage guidance. There is zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with constraints), no annotations, but a rich input schema (100% coverage) and an output schema (implied by 'Has output schema: true'), the description is mostly complete. It covers the core action and a key constraint, but lacks details on permissions, side effects, or error handling. The output schema reduces the need to explain return values, but more behavioral context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for both parameters (symbol as trading pair, margin_type as enum). The description adds no additional parameter semantics beyond what the schema provides, such as format examples or edge cases. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Switch margin type') and resource ('for a symbol'), distinguishing it from siblings like set_leverage or set_position_mode. It precisely identifies the two margin types (ISOLATED and CROSSED), making the purpose unambiguous and distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when NOT to use this tool: 'Cannot change margin type while a position or open order exists.' This provides clear exclusion criteria, helping the agent avoid incorrect invocations. It also implies usage context by mentioning positions and orders, which relate to sibling tools like get_positions and get_open_orders.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 the return behavior ('Returns {} on success'), which is valuable. However, it doesn't mention error conditions, timeout behavior, authentication requirements, or rate limits. For a connectivity testing tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: the first states the purpose and usage context, the second discloses the return behavior. No wasted words, perfectly front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, has output schema), the description is reasonably complete. It covers purpose, usage context, and return value. However, for a connectivity testing tool with no annotations, it could benefit from mentioning authentication requirements or error conditions to be fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, which is correct for this context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Test connectivity') and target resource ('Binance Futures API'), distinguishing it from all sibling tools which perform trading operations rather than connectivity checks. It provides a complete purpose statement with no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'Test connectivity to the Binance Futures API.' This provides clear context that this is for diagnostic/connection testing purposes rather than any trading operation, which is distinct from all sibling tools that handle orders, positions, or account data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes a critical constraint (cannot change with positions/orders open), which is essential for understanding when the operation will fail. However, it doesn't mention other potential behaviors like confirmation messages, error formats, or whether the change is immediate/reversible, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences: the first states the purpose, and the second provides critical usage guidance. Every word earns its place, and it's front-loaded with the main action, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (changing account mode with constraints), no annotations, and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose and key usage constraint but lacks details on permissions, rate limits, or error handling, which could be beneficial for full transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, with the parameter 'hedge_mode' fully documented in the schema itself. The description doesn't add any parameter-specific information beyond what's in the schema, but since there's only one parameter and the schema is complete, this is adequate. A baseline of 3 is adjusted to 4 due to the minimal parameter count and high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Switch between') and resource ('One-way Mode and Hedge Mode for the account'), distinguishing it from sibling tools like get_position_mode (which reads) and set_leverage/set_margin_type (which adjust different settings). It precisely defines what the tool does without being vague or tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides usage guidance with the note 'Cannot change while any positions or open orders exist,' which tells the agent when NOT to use this tool. This is crucial for avoiding errors, and no alternative tools are mentioned since this is the only tool for this specific function among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
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 and does so comprehensively. It explains critical behavioral traits: order execution timing (fill now vs wait for trigger), routing differences (conditional orders go to Algo API), position management rules (close entire vs partial position), and platform-specific constraints (max 1 SL + 1 TP active at a time, Binance limitations).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear headings and bullet points, making complex information digestible. While somewhat lengthy due to the tool's complexity, every section (order type groups, examples, important rules) serves a clear purpose. The front-loaded purpose statement is followed by logically organized supporting information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex 12-parameter trading tool with no annotations, the description provides exceptional completeness. It covers purpose, usage scenarios, behavioral characteristics, parameter relationships, and platform-specific constraints. The presence of an output schema means the description doesn't need to explain return values, allowing it to focus entirely on the critical operational knowledge needed to use this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline would be 3. However, the description adds significant value beyond the schema by providing concrete examples with actual parameter values for different order types, clarifying the relationships between parameters (like how close_position=True interacts with quantity), and explaining the practical implications of parameter combinations through the order type groups.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description immediately states the specific action ('Place a new futures order') with clear verb+resource. It distinguishes this tool from all sibling tools (like cancel_order, modify_order, get_open_orders) by focusing on order creation rather than modification, cancellation, or querying.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use different order type groups (Immediate vs Conditional orders) and includes critical usage rules about close_position=True vs quantity+reduce_only. It clearly distinguishes between different scenarios and warns against invalid combinations ('Never mix both on the same order').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-binance-futures MCP server](https://glama.ai/mcp/servers/Muvon/mcp-binance-futures/badges/card.svg)](https://glama.ai/mcp/servers/Muvon/mcp-binance-futures)

Score Badge

Copy to your README.md:

[![mcp-binance-futures MCP server](https://glama.ai/mcp/servers/Muvon/mcp-binance-futures/badges/score.svg)](https://glama.ai/mcp/servers/Muvon/mcp-binance-futures)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Muvon/mcp-binance-futures'

If you have feedback or need assistance with the MCP directory API, please join our Discord server