Derive MCP

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, with clear separation between account management, market data, order execution, and history queries. However, some overlap exists between get_ticker and get_tickers, and between get_my_trades and get_trade_history, which could cause minor confusion for an agent.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, such as get_account, place_order, and cancel_all_orders. This predictability makes it easy for agents to understand and navigate the toolset without ambiguity.
Tool Count3/5
With 31 tools, the count is borderline high for a trading platform server. While it covers many aspects comprehensively, it may feel heavy and potentially overwhelming for agents, though not extreme enough to be severely inappropriate.
Completeness5/5
The toolset provides complete coverage for a trading platform domain, including CRUD operations for orders, comprehensive account and market data access, historical queries, and specialized functions like RFQs and margin monitoring. No obvious gaps are present, enabling agents to handle full trading workflows.
Average 3.2/5 across 31 of 31 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Requires authentication' which is useful, but fails to describe critical behaviors: whether this is a destructive/mutative operation (implied by 'Cancel' but not explicit), what happens on success/failure, error conditions, or rate limits. For a mutation 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 extremely concise—two short sentences with zero wasted words. It's front-loaded with the core purpose ('Cancel an open order by order ID') followed by an essential requirement ('Requires authentication'), 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral outcomes (e.g., what 'cancel' entails, response format, error handling) and doesn't differentiate from sibling tools. Given the complexity of order management and the rich sibling set, more context is needed for the agent to use this tool effectively.
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 fully documents both parameters (subaccount_id and order_id). The description adds no additional parameter semantics beyond what's in the schema, such as format examples or constraints. Baseline 3 is appropriate when the schema does all the work.
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 ('Cancel') and resource ('an open order by order ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'cancel_all_orders' beyond the singular vs. plural distinction, missing an opportunity to clarify when to use one versus the other.
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 'cancel_all_orders' or 'replace_order'. It mentions authentication as a requirement but doesn't specify prerequisites (e.g., the order must be open) or contextual constraints, leaving the agent with minimal usage direction.
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 for behavioral disclosure. It mentions authentication requirement, which is useful, but fails to describe critical aspects: whether this is a read-only or destructive operation, what happens after execution (e.g., trade settlement, position changes), potential rate limits, or error conditions. For a financial transaction tool, this is inadequate.
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 at just two short sentences that get straight to the point. Every word serves a purpose with zero wasted information. It's perfectly front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a financial execution tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after execution, what the tool returns, error conditions, or how it differs from other trade-related tools. The authentication mention is helpful but doesn't compensate for the missing behavioral 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?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any additional meaning about what 'subaccount_id' or 'quote_id' represent beyond what's in the schema. This meets the baseline for high schema coverage but doesn't provide extra value.
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 ('execute') and resource ('quoted trade at the quoted price'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'place_order' or 'replace_order', which might also involve trade execution, so it doesn't reach the highest score.
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 'place_order' or 'replace_order'. It mentions authentication is required, but this is a basic prerequisite rather than usage context. There's no indication of when this specific execution method is 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Requires authentication', which is useful context, but lacks details on rate limits, error conditions, response format, or whether it's a read-only operation. For a tool with zero annotation coverage, this is insufficient.
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 purpose and includes an authentication requirement. Every word earns its place with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It covers the basic purpose and authentication need but lacks details on behavior, return values, or error handling. For a tool in a financial context with potential complexity, this leaves significant gaps.
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 the single parameter 'subaccount_id'. The description adds no additional meaning or context about the parameter beyond what's in the schema, such as format examples or constraints. 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' and resource 'collateral information for a subaccount', specifying the data includes amounts, prices, and margin contributions. It distinguishes from siblings like get_account or get_balance by focusing on collateral, but doesn't explicitly differentiate from get_margin which might overlap.
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 mentions 'Requires authentication', which is a prerequisite but not a usage guideline. It provides no guidance on when to use this tool versus alternatives like get_margin or get_balance, nor does it specify any exclusions or contexts for usage.
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 for behavioral disclosure. It mentions authentication requirements (helpful) but lacks critical details like pagination behavior, rate limits, error conditions, or what the output format looks like. For a read operation with 7 parameters, this leaves significant 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 (one sentence) and front-loaded with the core purpose. Every word earns its place, with no redundant information or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 7 parameters, the description is incomplete. It covers authentication but misses pagination behavior, return format, error handling, and usage context relative to siblings. For a financial data retrieval tool, this leaves too much unspecified.
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 fully documents all 7 parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain relationships between filters or how timestamps interact). Baseline 3 is appropriate when schema does all the work.
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 ('funding payments history') with scope ('paid and received'), making the purpose unambiguous. It doesn't explicitly differentiate from siblings like 'get_funding_rate_history', but the focus on payments vs. rates is implied.
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 mentions 'Requires authentication' as a prerequisite but provides no guidance on when to use this tool versus alternatives like 'get_deposit_history' or 'get_withdrawal_history'. No explicit when/when-not rules or sibling comparisons are included.
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 only states what data is retrieved without disclosing behavioral traits like pagination behavior (implied by page/page_size parameters), rate limits, authentication needs, or error handling. It mentions 'historical' but lacks details on data freshness or availability constraints.
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 historical funding rate data for perpetual contracts with timestamps and rates') directly contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a tool with 6 parameters and financial data complexity. It lacks details on return format, error cases, or operational constraints, leaving significant gaps for an AI agent to use it effectively.
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 fully documents all 6 parameters. The description adds no parameter-specific semantics beyond implying the tool handles perpetual contracts, which aligns with the instrument_name parameter. Baseline 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.
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 historical funding rate data') and resource ('for perpetual contracts'), specifying it includes timestamps and rates. It distinguishes from siblings like get_funding_history (likely broader) by focusing specifically on funding rates, though it doesn't explicitly contrast with all siblings.
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 on when to use this tool versus alternatives like get_funding_history or get_trade_history is provided. The description implies usage for historical funding rate data but offers no context about prerequisites, typical use cases, 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 the full burden of behavioral disclosure. It mentions authentication requirement, which is useful, but lacks details on rate limits, error handling, or what the tool returns (e.g., price format, units). For a read operation with no annotations, this leaves significant gaps in understanding behavior.
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 concise with two sentences that directly state the purpose and a key requirement. It is front-loaded with the main action and avoids unnecessary details, though it could be slightly more structured by integrating usage context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It covers authentication but omits critical details like return value format, error conditions, or how it interacts with sibling tools. For a tool that retrieves financial data, this leaves the agent with insufficient context for reliable 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 the input schema fully documents both parameters. The description does not add any extra meaning or context beyond what the schema provides, such as explaining how 'instrument_name' relates to open positions. Baseline score of 3 is appropriate as the schema handles parameter documentation.
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 the resource 'current liquidation price for an open position', making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get_positions' or 'get_margin', which might also relate to position data, so it misses full sibling distinction.
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 minimal guidance with 'Requires authentication', which is a basic prerequisite but does not specify when to use this tool versus alternatives like 'get_positions' or 'get_margin' for related position information. No explicit when/when-not or alternative tool references are included.
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 mentions authentication requirements, which is helpful, but lacks other critical behavioral traits: it doesn't specify if this is a read-only operation (implied by 'Get' but not explicit), doesn't mention rate limits, pagination behavior beyond schema hints, or what happens with large date ranges. For a tool with 7 parameters and no annotations, this leaves significant 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 and front-loaded: a single sentence that states the core purpose and authentication requirement. There's zero wasted text, and every word earns its place by conveying essential information efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema, no annotations), the description is incomplete. It lacks guidance on when to use it versus siblings, doesn't explain behavioral aspects like pagination or rate limits, and provides no information about return values. For a trade history tool with filtering and pagination, this leaves the agent with insufficient context to use it effectively.
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 7 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain parameter interactions, default behaviors beyond schema defaults, or usage examples. This meets the baseline for high schema coverage but doesn't provide extra value.
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 personal trade history with detailed trade information (side, price, fees, PnL).' It specifies the verb ('Get'), resource ('personal trade history'), and scope of information returned. However, it doesn't explicitly differentiate from sibling tools like 'get_trade_history' or 'get_orders_history,' which might have overlapping functionality.
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 minimal usage guidance: 'Requires authentication' indicates a prerequisite but doesn't explain when to use this tool versus alternatives. No context is given about when this tool is appropriate compared to siblings like 'get_trade_history' or 'get_orders_history,' leaving the agent without clear selection criteria.
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 'historical' data, implying read-only behavior, but doesn't disclose critical behavioral traits like pagination handling (implied by page/page_size parameters but not explained), rate limits, authentication requirements, or what happens with missing parameters. The description is too brief to adequately cover behavioral aspects.
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 a single, efficient sentence that front-loads the core purpose. It wastes no words, though it could potentially be more structured if it included usage notes. Every word earns its place in conveying 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?
For a data retrieval tool with 5 parameters and no output schema, the description is minimally complete. It identifies the data type but lacks context about return format, error conditions, or relationship to other tools. The high schema coverage helps, but without annotations or output schema, 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%, providing good documentation for all 5 parameters. The description adds no parameter-specific information beyond what's in the schema, but the schema itself is comprehensive with descriptions, defaults, and constraints. 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.
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 'historical option settlement data', with specific data elements listed (expiry, settlement prices, PnL). It distinguishes from many siblings that deal with different financial data types (e.g., trades, orders, balances), though it doesn't explicitly differentiate from similar historical data tools like get_trade_history or get_funding_history.
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. The description doesn't mention any prerequisites, exclusions, or specific contexts for usage, leaving the agent to infer based on the tool name and data type 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 mentions 'Requires authentication', which is a useful behavioral trait, but lacks other critical details such as whether this is a read-only operation, potential rate limits, error handling, or the format of returned data. For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.
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 concise and front-loaded, consisting of two sentences that efficiently convey the tool's purpose and a key requirement. There is no wasted text, and it directly addresses what the tool does and a necessary condition ('Requires authentication'), making it appropriately sized for its content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of retrieving financial positions with no annotations and no output schema, the description is incomplete. It mentions authentication but omits other behavioral aspects like safety (read-only vs. destructive), response format, or error cases. For a tool that handles sensitive financial data, this lack of context makes it insufficient for an agent to fully understand how to use it effectively.
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, providing clear documentation for all parameters (subaccount_id, currency, instrument_type). The description does not add any additional meaning beyond what the schema already states, such as explaining parameter interactions or default behaviors. With high schema coverage, the baseline score of 3 is appropriate, as the description relies on the schema for parameter details.
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 all open positions for a subaccount' with specific details like 'unrealized PnL, mark price, leverage, and liquidation price'. It uses a specific verb ('Get') and resource ('open positions'), but does not explicitly differentiate from sibling tools like 'get_account' or 'get_balance', which might also retrieve financial data. This makes it clear but not fully sibling-distinctive.
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 minimal usage guidance: it mentions 'Requires authentication', which is a prerequisite, but offers no explicit advice on when to use this tool versus alternatives. For example, it does not compare to 'get_account' for general account info or 'get_balance' for specific balances, leaving the agent to infer usage from context without clear exclusions or alternatives.
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 for behavioral disclosure. It only mentions authentication requirement and basic return data (transaction hashes and statuses). Missing critical behavioral information: pagination behavior (implied by page parameters but not explained), rate limits, error conditions, whether it's read-only (implied by 'Get' but not explicit), or what format/scope the history covers beyond the mentioned fields.
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 appropriately concise with two clear sentences. The first sentence states the core purpose, the second adds the authentication requirement. No wasted words or redundant information. Could be slightly improved by front-loading authentication requirement if critical, but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 annotations and no output schema, the description is insufficient. It lacks information about return format, pagination behavior, error handling, rate limits, and how it differs from similar history tools. The authentication mention is helpful but doesn't compensate for missing behavioral context needed for proper tool 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%, providing complete parameter documentation. The description adds no parameter-specific information beyond what's in the schema. It doesn't explain how parameters interact (e.g., timestamp filtering logic) or provide usage examples. With high schema coverage, baseline 3 is appropriate as the description doesn't add value beyond the structured schema.
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 ('withdrawal history'), including key data elements ('transaction hashes and statuses'). It distinguishes itself from siblings like 'get_deposit_history' by focusing on withdrawals, but doesn't explicitly differentiate from other history tools beyond the withdrawal 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?
The description provides no guidance on when to use this tool versus alternatives. While it mentions authentication requirement, it doesn't explain when withdrawal history is needed compared to other history tools (deposit, funding, trade) or how it relates to account/balance tools. No explicit when/when-not instructions or sibling comparisons are provided.
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 mentions authentication but lacks details on rate limits, response format, whether this is a read-only or mutative operation, or potential side effects (e.g., does sending an RFQ commit to a trade?). This is inadequate for a tool that likely involves financial transactions.
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 concise and front-loaded with the core purpose in the first sentence. The second sentence adds necessary authentication info. Both sentences earn their place, though it could be slightly more structured (e.g., separating prerequisites).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of financial operations, no annotations, and no output schema, the description is insufficient. It doesn't cover behavioral traits, response expectations, or error handling. For a tool that interacts with market makers, more context on what happens after sending the RFQ is needed.
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 fully documents all four parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't clarify 'amount' units or 'instrument_name' format). This meets the baseline of 3 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.
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: 'Send a Request For Quote to get custom pricing from market makers.' It specifies the verb ('Send'), resource ('Request For Quote'), and outcome ('get custom pricing'). However, it doesn't explicitly differentiate from sibling tools like 'execute_quote' or 'get_rfqs', which would be needed for a score of 5.
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 minimal guidance: 'Requires authentication' is a basic prerequisite but doesn't explain when to use this tool versus alternatives like 'place_order' or 'execute_quote'. No context on when-not-to-use or specific scenarios is given, leaving the agent with little practical direction.
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 that the tool returns detailed information, but does not disclose behavioral traits like rate limits, authentication requirements, pagination, or error handling. This is a significant gap for a tool with no annotation coverage.
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 appropriately sized and front-loaded, with two sentences that efficiently convey the tool's purpose and return value without unnecessary details. Every sentence earns its place by adding relevant 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?
Given the complexity (3 parameters, no output schema, no annotations), the description is moderately complete. It covers the purpose and return content but lacks details on usage guidelines, behavioral traits, and output structure, which are needed for full contextual understanding.
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. The description adds minimal value by implying filtering by currency and type, but does not provide additional semantics beyond what the schema specifies, such as examples or constraints not in the enum.
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 specific verbs ('Get all active instruments') and resources ('instruments for a specified currency and type'), and mentions the return content ('detailed information about tradeable assets including fees, constraints, and Greeks'). However, it does not explicitly differentiate from sibling tools like 'get_currencies' or 'get_tickers', which reduces the score from 5 to 4.
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, exclusions, or compare it to sibling tools such as 'get_currencies' or 'get_tickers', leaving the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. While 'Get' implies a read operation, the description doesn't specify whether this requires authentication, what rate limits might apply, what format the history data returns, or whether it's paginated (though the schema hints at pagination). For a history retrieval tool with zero annotation coverage, this leaves significant behavioral questions unanswered.
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 states the core purpose without unnecessary words. It's appropriately sized for a straightforward retrieval tool and front-loads the essential information. Every word earns its place with zero waste.
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 (6 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks context about authentication requirements, rate limits, return format, or how it fits with sibling tools. Without annotations or output schema, the description should provide more behavioral context for a history retrieval 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 schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here.
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 ('liquidation events history across the platform'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_liquidation_price' or other history tools, but the scope 'across the platform' provides some distinction. This is clear but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, what prerequisites might exist, or how it differs from other history tools like 'get_trade_history' or 'get_funding_history'. There's only a basic statement of purpose without usage context.
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 mentions authentication requirements, which is useful, but lacks details on rate limits, error conditions, response format, or whether this is a read-only operation (implied by 'Get' but not explicit). For a tool with no annotations, this leaves significant gaps in understanding its 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 purpose and includes essential context (authentication). There is no wasted verbiage or redundancy, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the purpose and authentication but lacks details on return values, error handling, or behavioral traits. Without annotations or output schema, more context 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?
Schema description coverage is 100%, with the parameter 'subaccount_id' fully documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints. Baseline score of 3 is appropriate as the schema handles 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') and resource ('detailed margin information for a subaccount'), specifying the types of margin data retrieved (maintenance margin, initial margin, margin ratio). It distinguishes this from siblings like get_account or get_balance by focusing on margin-specific metrics, though it doesn't explicitly contrast with all siblings.
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 includes 'Requires authentication,' which is a basic prerequisite but not a usage guideline. It provides no guidance on when to use this tool versus alternatives like get_account (which might include margin data) or margin_watch (which might monitor margin changes), nor does it specify any exclusions or contexts for use.
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. It discloses authentication requirements but lacks critical behavioral details: it doesn't mention pagination behavior (implied by page/page_size parameters), rate limits, error conditions, what happens with invalid subaccount_id, or the format/structure of returned order history. For a tool with 5 parameters and no output schema, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two clear sentences. The first sentence states purpose and scope, the second adds authentication requirement. No wasted words, though it could be slightly more informative given the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address the pagination behavior (critical for understanding how to retrieve all history), doesn't explain the relationship between currency and instrument_name filters, doesn't mention response format, and provides minimal behavioral context. The authentication mention is helpful but insufficient.
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 fully documents all 5 parameters. The description adds minimal value beyond the schema - it mentions 'subaccount' which aligns with subaccount_id, and 'filled, cancelled, and rejected orders' which relates to the tool's purpose but not specific parameters. It doesn't explain parameter interactions or provide additional context beyond what's in the schema descriptions.
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 'order history for a subaccount', specifying it includes 'filled, cancelled, and rejected orders'. This distinguishes it from siblings like get_open_orders (which only shows active orders) and get_trade_history (which shows executed trades). However, it doesn't explicitly mention pagination or filtering capabilities that are evident from the schema.
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 stating 'Requires authentication' and specifying it's for 'a subaccount', which helps differentiate from tools like get_account. However, it doesn't explicitly say when to use this versus alternatives like get_open_orders (for active orders) or get_trade_history (for executed trades), nor does it mention prerequisites beyond authentication.
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. It discloses authentication needs, which is useful, but lacks details on behavioral traits such as rate limits, pagination, error handling, or what happens if the wallet is invalid. For a read operation with zero annotation coverage, this leaves significant 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 two sentences, front-loaded with the core purpose and followed by an authentication requirement. Every sentence adds value with zero waste, making it appropriately sized and efficient.
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 no annotations, no output schema, and a simple parameter schema, the description is minimally adequate. It covers authentication and data scope but lacks details on return format, error cases, or performance considerations. For a read tool in this context, it meets basic needs but has clear gaps.
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 fully documents the single parameter. The description adds no additional parameter semantics beyond implying the wallet is used to fetch subaccounts, which is already clear from the schema. 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' and resource 'all subaccounts for a wallet', specifying what data is retrieved (labels and creation timestamps). It distinguishes from siblings like get_account or get_balance by focusing on subaccounts, though it doesn't explicitly contrast with them.
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 mentions 'Requires authentication', which is a prerequisite, but provides no guidance on when to use this tool versus alternatives like get_account or get_balance. There is no explicit when/when-not context or sibling differentiation beyond the resource focus.
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 adds value by stating 'Requires authentication', which is crucial context not in the schema. However, it doesn't describe what 'account details' actually returns (format, structure), whether it's a read-only operation (implied by 'Get'), rate limits, or error conditions. For a tool with no annotations, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two concise sentences. The first sentence front-loads the purpose and key details, while the second adds authentication requirement. There's no wasted text, though it could be slightly more structured (e.g., separating purpose from returned details).
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 no annotations and no output schema, the description should do more to explain what 'account details' returns and behavioral aspects. It covers authentication requirement and lists example details, but doesn't provide return format, error handling, or usage context. For a tool with 1 parameter but complex return data implied by the details listed, this is minimally adequate but has clear gaps.
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 the single 'wallet' parameter. The description adds no parameter-specific information beyond what's in the schema. According to the rules, with high schema coverage (>80%), the baseline is 3 even with no param info in the description, which applies here.
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 'account details', with specific examples of what details are included (subaccounts, rate limits, fee structure, account status). It distinguishes from siblings like get_balance or get_subaccounts by specifying a broader account overview rather than specific components. However, it doesn't explicitly contrast with all siblings, 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.
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_balance, get_subaccounts, or get_margin. It mentions 'Requires authentication' which is a prerequisite, but doesn't indicate when this tool is appropriate versus other account-related tools. There's no explicit when/when-not or alternative recommendations.
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 'Get all available currencies' but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, rate limits, pagination, or what the return format looks like. For a tool with zero annotation coverage, this is inadequate.
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 all available currencies') and adds clarifying detail ('underlying assets on the platform'). There is no wasted verbiage or redundancy.
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, no output schema), the description is minimally adequate but lacks depth. It doesn't explain what 'currencies' or 'underlying assets' entail in this context, nor does it cover behavioral aspects like response format or constraints, leaving gaps for an AI agent.
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 schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately doesn't mention any. Baseline for 0 parameters is 4.
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 ('all available currencies/underlying assets on the platform'), making the purpose specific and understandable. It doesn't explicitly differentiate from siblings like 'get_instruments' or 'get_ticker', but the focus on currencies/underlying assets provides reasonable implicit distinction.
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_instruments' or 'get_ticker', nor does it mention prerequisites, context, or exclusions. It simply states what the tool does without usage context.
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. While it mentions authentication requirements, it doesn't describe what 'active RFQs' means operationally, whether there are rate limits, pagination behavior, error conditions, or what format the response takes. For a read operation 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 extremely concise at just two sentences with zero wasted words. It's front-loaded with the core purpose and efficiently adds the authentication requirement. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description should provide more complete context for this read operation. It doesn't explain what constitutes 'active' RFQs, what 'quotes received' means, the response format, or any limitations. For a tool that presumably returns business-critical RFQ data, this is insufficient contextual information.
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 'subaccount_id' fully documented in the schema. The description doesn't add any additional parameter semantics beyond what the schema already provides. With complete schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 active RFQs') and resource ('for a subaccount with quotes received'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from potential sibling RFQ-related tools like 'send_rfq', leaving room for ambiguity about when to use each.
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 includes 'Requires authentication' which provides some context about prerequisites, but offers no explicit guidance on when to use this tool versus alternatives like 'get_orders_history' or 'send_rfq'. The usage context is implied rather than clearly articulated.
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 only states what data is retrieved without behavioral details. It doesn't disclose pagination behavior (implied by page/page_size), rate limits, authentication needs, or error handling, which are critical for a historical data tool with multiple parameters.
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 earns its place by specifying data type, historical nature, and timestamp inclusion.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no output schema, no annotations), the description is incomplete. It lacks details on return format, pagination behavior, error cases, and how it differs from similar historical tools, making it inadequate for full agent understanding.
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 fully documents all parameters. The description adds no additional meaning beyond implying timestamp filtering and 'index prices' context, which is already covered by parameter descriptions. Baseline 3 is appropriate as the schema handles parameter semantics.
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 as 'Get historical spot price feed data (index prices) with timestamps,' which specifies the verb ('Get'), resource ('historical spot price feed data'), and scope ('with timestamps'). It distinguishes from siblings like get_ticker (current prices) and get_trade_history (trades), but doesn't explicitly mention 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 for historical index price data, suggesting when to use it versus real-time tools. However, it lacks explicit guidance on when not to use it or direct alternatives like get_funding_rate_history for funding rates, leaving some ambiguity.
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 mentions authentication requirements, which is useful, but lacks details on rate limits, response format, whether it's read-only or has side effects, or any other behavioral traits. For a tool with no annotations, this is insufficient.
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 that directly state the purpose and a key requirement. Every word earns its place, and it's front-loaded with the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It covers authentication but misses critical details like what the output looks like (e.g., list of accounts, thresholds), whether it's a read operation, or any error conditions. For a tool with no structured support, this leaves significant gaps.
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 for its single parameter ('wallet'), so the schema already documents it well. The description doesn't add any parameter-specific information beyond what's in the schema, but with high schema coverage, the baseline is 3.
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 ('margin watch information'), and specifies what the information shows ('accounts approaching liquidation'). It doesn't explicitly differentiate from siblings like 'get_liquidation_history' or 'get_liquidation_price', but the focus on 'approaching liquidation' provides some distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance by stating 'Requires authentication,' which suggests when to use it (when authenticated) but doesn't explicitly say when to choose this tool over alternatives like 'get_liquidation_history' or 'get_margin'. No explicit when-not or alternative guidance 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 the full burden of behavioral disclosure. It adds value by stating 'Requires authentication,' which is a critical behavioral trait not covered elsewhere. However, it lacks details on rate limits, pagination behavior (implied by page parameters but not explained), error conditions, or response format, leaving significant gaps for a tool with 5 parameters and no output schema.
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 just two short sentences that are front-loaded with the core purpose. Every word earns its place: the first sentence defines the tool's function, and the second provides essential authentication context. There's no redundancy or unnecessary elaboration.
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 (5 parameters, no output schema, no annotations), the description is incomplete. It covers authentication needs but omits critical context like response structure, pagination behavior, error handling, and how it differs from sibling history tools. While concise, it leaves too many operational questions unanswered for effective 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 the schema fully documents all 5 parameters with clear descriptions and defaults. The description adds no parameter-specific semantics beyond what's in the schema—it doesn't explain relationships between parameters (e.g., timestamp ranges) or provide usage examples. This meets the baseline for high schema coverage but doesn't enhance understanding.
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 as 'Get deposit history with transaction hashes and statuses,' which is a specific verb+resource combination. It distinguishes itself from siblings like get_balance or get_withdrawal_history by focusing on deposit transactions. However, it doesn't explicitly differentiate from get_funding_history or get_trade_history, which might overlap in financial contexts.
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 mentions 'Requires authentication,' but this is a prerequisite rather than usage context. There's no indication of when to choose this over similar history tools like get_funding_history or get_withdrawal_history, leaving the agent to infer based on tool names 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. It mentions 'real-time' data but doesn't disclose behavioral traits like rate limits, authentication requirements, whether the data is cached, error conditions, or response format. For a real-time data tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
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 real-time ticker data for a single instrument') and appends key details (data fields). Every word earns its place with no redundancy or fluff, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of real-time financial data, no annotations, and no output schema, the description is incomplete. It lists data fields but doesn't explain return values, error handling, or operational constraints. For a tool with no structured output or behavioral annotations, more context is needed to be fully helpful.
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 the single parameter 'instrument_name' documented in the schema. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples of instrument formats beyond the schema's 'e.g., ETH-20250131-3000-C, BTC-PERP, USDC'). With high schema coverage, the baseline is 3, and the description doesn't compensate further.
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 real-time ticker data') and resource ('for a single instrument'), distinguishing it from sibling tools like get_tickers (plural) and get_orderbook. It lists the specific data fields returned (bid/ask, last price, 24h volume, Greeks for options), making the purpose explicit 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying 'for a single instrument' and listing data fields, suggesting it's for real-time price/volume/Greeks queries. However, it doesn't explicitly state when to use this vs. alternatives like get_tickers (for multiple instruments) or get_orderbook (for depth data), 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. It discloses authentication requirements, which is useful behavioral context. However, it lacks details on rate limits, pagination, error handling, or response format, leaving gaps in behavioral traits for a read operation with potential complexity.
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 purpose and includes essential authentication note. Every word contributes value without redundancy, making it appropriately sized and well-structured.
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 no annotations and no output schema, the description provides basic purpose and authentication but lacks details on return values, error cases, or operational constraints. For a tool with three parameters and sibling complexity, it is minimally adequate but has clear gaps in completeness.
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 fully documents the parameters. The description adds no additional meaning beyond implying filtering by currency and instrument name, but does not elaborate on syntax or usage. Baseline 3 is appropriate as the schema handles parameter documentation adequately.
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 the resource 'all open orders for a subaccount', specifying order status and details. It distinguishes from siblings like 'get_orders_history' by focusing on open orders, but does not explicitly compare or differentiate beyond this scope, making it clear but not fully sibling-aware.
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 open orders from a subaccount, but does not provide explicit guidance on when to use this tool versus alternatives like 'get_orders_history' or 'get_my_trades'. It mentions authentication as a prerequisite, offering some context, but lacks details on exclusions or specific scenarios.
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 'real-time' data, which hints at dynamic updates, but lacks details on rate limits, authentication needs, data freshness, or response format. For a data-fetching tool with zero annotation coverage, this is a significant gap 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.
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 real-time orderbook data') and includes key details without waste. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 (fetching real-time market data), no annotations, and no output schema, the description is adequate but incomplete. It specifies what data is retrieved but lacks details on return values, error handling, or operational constraints, leaving gaps for an AI agent to infer 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?
Schema description coverage is 100%, so the schema already documents both parameters (instrument_name and depth) with descriptions and defaults. The description adds no additional parameter semantics beyond what the schema provides, such as examples or format details, meeting the baseline for 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 ('Get real-time orderbook data'), the resource ('for a specific instrument'), and distinguishes it from siblings by specifying the data content ('bid/ask levels, depth, and spread'), which is unique among tools like get_ticker or get_tickers that provide different market data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 orderbook data, but does not explicitly state when to use this tool versus alternatives like get_ticker (for price only) or get_instruments (for instrument details). No guidance on prerequisites or exclusions is provided, leaving usage context inferred rather than defined.
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 authentication requirement, which is valuable behavioral context. However, it doesn't describe response format, rate limits, error conditions, or whether this is a read-only operation (though 'Get' implies it).
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 concise sentences with zero waste. First sentence states purpose and scope, second states authentication requirement. Every word earns its place.
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 single-parameter read tool with no output schema, the description covers purpose and authentication adequately. However, it lacks information about response format, data structure, or what happens when wallet parameter is omitted (default behavior implied but not explicit).
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 the single parameter. The description doesn't add any parameter-specific information beyond what the schema provides, maintaining the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific verb 'Get' and resource 'account balance' with detailed scope 'across all subaccounts including collaterals and open order margins'. It distinguishes from siblings like get_account, get_collaterals, and get_margin by specifying this tool aggregates multiple balance components.
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 needing comprehensive balance information, but doesn't explicitly state when to use this vs. alternatives like get_account or get_collaterals. No exclusions or specific prerequisites beyond authentication are mentioned.
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 key behavioral traits: the tool provides 'detailed trade information' and 'supports filtering and pagination.' However, it doesn't mention rate limits, authentication requirements, data freshness, or whether this includes only settled trades versus all trade attempts.
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 - a single sentence that front-loads the core purpose and includes only essential additional information about filtering and pagination. Every word earns its place with zero redundancy or wasted space.
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 read-only tool with 10 well-documented parameters but no output schema, the description is adequate but could be more complete. It doesn't describe the return format (array of trades? structured object?), pagination behavior (total count? next page token?), or clarify what 'tick-by-tick' means operationally. With no annotations and no output schema, more behavioral context would be helpful.
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 10 parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'filtering' (implied by parameters) and 'pagination' (implied by page/page_size parameters) but doesn't provide additional semantic context about parameter interactions or usage patterns.
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 ('tick-by-tick trade history') with specific details about what information is included (price, size, buyer/seller, timestamp). It distinguishes from siblings like 'get_my_trades' (personal trades) by describing a comprehensive historical dataset.
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 detailed historical trade data with filtering capabilities, but doesn't explicitly state when to use this versus alternatives like 'get_my_trades' (personal trades) or 'get_orders_history' (order history). No explicit when-not-to-use guidance or prerequisite information 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 the full burden of behavioral disclosure. It mentions the authentication requirement, which is valuable context. However, it doesn't describe important behavioral aspects like whether this is an atomic operation, what happens if some orders fail to cancel, or what the response format looks like.
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 efficient - just two sentences that communicate the core functionality, optional features, and authentication requirement with zero wasted words. It's perfectly front-loaded with the main 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?
For a destructive operation with no annotations and no output schema, the description is somewhat incomplete. While it covers the basic purpose and authentication requirement, it doesn't address important aspects like error handling, response format, or the irreversible nature of order cancellation.
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 documents all three parameters thoroughly. The description adds minimal value by mentioning the optional filtering capability, but doesn't provide additional semantic context beyond what's in the schema 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 target resource ('for a subaccount'), with optional filtering capabilities. It distinguishes itself from the sibling 'cancel_order' tool by handling multiple orders rather than a single order.
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 ('Cancel all open orders for a subaccount') and mentions optional filtering parameters. However, it doesn't explicitly state when NOT to use it or directly 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.
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 states that the tool requires authentication and a private key for signing, which are critical behavioral traits for a financial transaction tool. However, it does not mention potential side effects like rate limits, order confirmation details, or error handling.
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 and essential requirements. Every word earns its place, with no redundant or unnecessary information, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a financial order placement tool with no annotations and no output schema, the description is incomplete. It covers authentication needs but lacks details on return values, error conditions, or behavioral nuances like order execution guarantees, which are crucial for such a high-stakes 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?
The input schema has 100% description coverage, so the schema already documents all parameters thoroughly. The description does not add any additional meaning or context beyond what the schema provides, such as explaining parameter interactions or trade-offs between order types.
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 ('Place') and resource ('a new order'), specifies the order types ('limit or market'), and distinguishes this tool from siblings like cancel_order, replace_order, and execute_quote by focusing on creation rather than modification or execution of quotes.
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 creating orders but does not explicitly state when to use this tool versus alternatives like replace_order or execute_quote. It mentions authentication requirements, which provides some context, but lacks explicit guidance on tool selection among siblings.
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 full burden and does well by disclosing key behavioral traits: it's an atomic operation (important transactional guarantee), requires authentication (security context), and involves both cancellation and creation (destructive nature). However, it doesn't mention rate limits, error conditions, or what happens if the original order doesn't exist.
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: the first sentence explains the core operation with important qualifiers ('atomic'), and the second provides critical authentication requirement. Every word earns its place with front-loaded 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?
For a mutation tool with no annotations and no output schema, the description does well by explaining the atomic nature and authentication requirement. However, it doesn't describe return values or error scenarios, leaving some gaps in completeness for a tool that modifies financial orders.
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 four parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions, maintaining the baseline score for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('replace an existing order') with precise operational details ('cancel old and place new in one atomic operation'), distinguishing it from siblings like 'cancel_order' and 'place_order' which perform separate functions.
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 'replace an existing order' and mentioning authentication, but doesn't explicitly state when to use this tool versus alternatives like manually canceling and placing orders separately. No explicit exclusions or sibling comparisons are 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 for behavioral disclosure. It mentions efficiency characteristics (bulk query optimization) which is valuable context, but doesn't describe response format, rate limits, error conditions, or whether this is a read-only operation. It provides some behavioral insight but leaves significant 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?
Two perfectly efficient sentences with zero waste. The first establishes core functionality, the second provides crucial comparative guidance. Every word earns its place, and the most important information (purpose and when to use) is front-loaded.
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 read operation with 2 optional parameters and 100% schema coverage but no output schema, the description provides good purpose and usage guidance but lacks information about return format, pagination, or error handling. The sibling comparison is excellent, but without annotations or output schema, more behavioral context would be helpful.
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. It mentions querying 'multiple instruments' which implies the tool returns data for multiple items, but doesn't clarify parameter usage or relationships.
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 ticker information') and resource ('multiple instruments at once'), and explicitly distinguishes it from its sibling tool 'get_ticker' by highlighting efficiency advantages for bulk queries. This provides perfect differentiation from alternatives.
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 this tool versus its sibling: 'More efficient than get_ticker when querying many instruments.' This clearly indicates the optimal use case and names the alternative tool, giving the agent perfect decision-making context.
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:

[![derive-MCP MCP server](https://glama.ai/mcp/servers/solenyaresearch0000/derive-MCP/badges/card.svg)](https://glama.ai/mcp/servers/solenyaresearch0000/derive-MCP)

Score Badge

Copy to your README.md:

[![derive-MCP MCP server](https://glama.ai/mcp/servers/solenyaresearch0000/derive-MCP/badges/score.svg)](https://glama.ai/mcp/servers/solenyaresearch0000/derive-MCP)

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/solenyaresearch0000/derive-MCP'

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