MCP Paradex Server

Overview Schema Source Related Servers Score Discussions Admin

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 boundaries, such as paradex_account_fills for executed trades and paradex_account_positions for open positions. However, some overlap exists between paradex_account_summary and paradex_vault_account_summary, which could cause confusion in selecting the right tool for account overviews, and between paradex_markets and paradex_market_summaries for market information. The descriptions help clarify, but minor ambiguity remains.
Naming Consistency5/5
All tool names follow a consistent snake_case pattern with a clear 'paradex_' prefix, and most use a verb_noun structure (e.g., paradex_create_order, paradex_cancel_orders). The naming is highly predictable and uniform across all 26 tools, making it easy for agents to understand and navigate the toolset without confusion.
Tool Count3/5
With 26 tools, the count is borderline high for a trading server, as it may feel heavy and overwhelming for agents to manage. While the tools cover a comprehensive range of trading functions (e.g., account management, order execution, market data), some could potentially be consolidated (e.g., multiple vault-related tools) to reduce complexity without losing functionality.
Completeness5/5
The toolset provides complete coverage for a trading platform, including CRUD operations (e.g., create_order, cancel_orders), account and vault management, market data analysis, and system monitoring. There are no obvious gaps; tools like paradex_filters_model support advanced filtering, and lifecycle coverage (e.g., from order creation to history) is thorough, ensuring agents can handle all typical trading workflows without dead ends.
Average 4.1/5 across 26 of 26 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
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?
No annotations are provided, so the description carries full burden. It states the tool retrieves historical orders but doesn't disclose behavioral traits like whether it requires authentication, has rate limits, returns paginated results, or what format the data comes in. For a read operation with no 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with three sentences that each add value: stating the purpose, specifying order types, and explaining usefulness. It's front-loaded with the core function and wastes no words, though it could be slightly more structured with explicit usage boundaries.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (historical data retrieval with three required parameters), no annotations, and no output schema, the description is minimally adequate. It covers what the tool does but lacks details about authentication requirements, response format, pagination, or error handling that would be 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 three parameters (market_id, start_unix_ms, end_unix_ms) with their descriptions. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score 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 tool's purpose as 'Get historical orders' and specifies it retrieves order history including filled, canceled, and expired orders. It distinguishes itself from sibling tools like paradex_open_orders (current orders) and paradex_account_fills (executed trades), though it doesn't explicitly name these alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for analyzing past trading activity and performance, suggesting when this tool is appropriate. However, it doesn't provide explicit guidance on when to use this versus alternatives like paradex_account_fills or paradex_open_orders, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that this retrieves filtered history and mentions avoiding overwhelming results, which hints at potential data volume issues. However, it doesn't cover important behavioral aspects like whether this is a read-only operation, authentication requirements, rate limits, pagination behavior, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by elaboration, usage guidance, and bulleted use cases. Each sentence adds value, though the bulleted list could be more concise. The information is appropriately front-loaded with the core functionality stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (so return values are documented elsewhere), 100% schema coverage, and no complex nested objects, the description provides adequate context. It covers purpose, usage guidance, and valuable applications. The main gap is lack of behavioral transparency details that would be important for a tool accessing transaction history.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description mentions using 'transaction_type and time filters' which aligns with the schema parameters, but adds no additional semantic context beyond what's in the schema. The baseline score of 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 account transaction history' and elaborates on what types of transactions are included (deposits, withdrawals, trades, funding payments). It distinguishes this tool from siblings like paradex_account_funding_payments by covering multiple transaction types, but doesn't explicitly contrast with paradex_account_fills or paradex_orders_history 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: 'Use transaction_type and time filters to limit the results and avoid overwhelming the client.' It also lists valuable use cases (reconciliation, auditing, tracking, analyzing). However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools.
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 explains what the tool provides (historical candlestick data for technical analysis) and mentions use cases, but doesn't disclose important behavioral traits like whether this is a read-only operation, rate limits, authentication requirements, or what format the output takes. The description adds value but leaves significant gaps for a tool that fetches historical market data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a clear purpose statement, but contains redundancy (multiple bullet points that essentially restate technical analysis applications) and could be more concise. The 'Example use cases' section largely repeats concepts from the 'Use this tool when you need to' section, suggesting some sentences don't earn their place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (per context signals), the description doesn't need to explain return values. For a data retrieval tool with good parameter documentation in the schema, the description provides adequate context about what the tool does and when to use it. However, with no annotations, it could better address behavioral aspects like data freshness, limitations, or error conditions.
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 4 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema - it doesn't explain the significance of 'resolution' values, how to interpret market_id format, or provide guidance on time range selection. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 analyzing historical price patterns for technical analysis and trading decisions, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'paradex_trades' or 'paradex_market_summaries' which might also provide price-related data, though the focus on candlestick data and technical analysis provides some 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage contexts with a bulleted list of when to use the tool (technical analysis, identifying support/resistance, calculating indicators, backtesting, visualizing). It doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, but the context is well-defined and helpful for an agent.
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 effectively describes the tool's function as a read-only analysis tool for open positions, including aspects like exposure and risk monitoring, which implies non-destructive behavior. However, it lacks details on potential limitations, such as data freshness, rate limits, or authentication requirements, leaving some behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage guidelines, example use cases) and uses bullet points for readability. It avoids unnecessary repetition and stays focused on essential information, though it could be slightly more concise by integrating some points into fewer sentences without losing clarity.
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 (analyzing positions with no parameters) and lack of annotations and output schema, the description does a decent job covering purpose and usage. However, it doesn't explain what the output looks like (e.g., data format, fields returned), which is a gap since there's no output schema to rely on, making it less complete for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and usage without redundant parameter details, adding value by explaining what the tool does rather than how to call it, which aligns well with the schema's completeness.
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 analyzing open positions to monitor exposure, profitability, and risk, which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'paradex_vault_positions' or 'paradex_account_summary', which might also provide position-related information, leaving some ambiguity about its unique scope.
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 a bulleted list of specific use cases (e.g., checking P&L, monitoring liquidation prices) and states it's for analyzing open positions, which gives clear context on when to use it. However, it doesn't explicitly mention when not to use it or name alternatives among siblings, such as for historical positions or vault-specific data, which could improve guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool tracks funding payment history and explains why this matters for P&L calculations. However, it doesn't describe behavioral traits like whether this is a read-only operation, what permissions are needed, rate limits, pagination, or error conditions. The description adds useful context about funding's impact but lacks operational details.
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 and well-structured with clear sections: purpose statement, when-to-use bullet points, context about funding impact, and example use cases. Every sentence adds value, though the example use cases section somewhat overlaps with the usage guidelines. The description could be slightly more concise by integrating these sections.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, no output schema), the description provides good contextual completeness. It explains the purpose, usage scenarios, and importance of funding payments for trading. However, without annotations or output schema, it doesn't cover behavioral aspects like response format, error handling, or authentication requirements, which would be helpful for a financial data 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%, so the schema already documents all three parameters (market_id, start_unix_ms, end_unix_ms) with descriptions. The description doesn't add any parameter-specific information beyond what's in the schema. It implies filtering by market and time ranges through the use cases but doesn't provide additional syntax or format details. 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 tool's purpose as tracking funding payment history to understand its impact on P&L, which is specific (verb+resource). It distinguishes from siblings like paradex_account_summary or paradex_account_transactions by focusing specifically on funding payments rather than general account data. However, it doesn't explicitly contrast with paradex_funding_data, which might be a related sibling.
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 with a bulleted list of when to use this tool ('Calculate total funding costs...', 'Analyze how funding has affected...', etc.). It gives clear context about funding payments impacting perpetual futures trading P&L, especially for longer-term positions. The example use cases section further reinforces appropriate usage scenarios.
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. It effectively discloses key behavioral traits: it's a mutation tool (canceling orders), includes risk management context, explains the default behavior (cancel all orders if no parameters), and notes that successful response means orders are 'queued for cancellation' with a follow-up step to check status. However, it lacks details on permissions, rate limits, 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose but includes repetitive sections (e.g., 'Example use cases' largely rephrases earlier bullet points). It could be more streamlined, though all content is relevant to understanding the tool's use.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (mutation with risk implications) and no annotations, the description does a good job covering purpose, usage, and behavior. With an output schema present, it doesn't need to explain return values, and it includes practical examples. Minor gaps exist in error handling or advanced constraints.
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 (order_id, client_id, market_id). The description adds minimal value beyond the schema, only implying parameter usage through examples (e.g., 'Canceling a specific order identified by order ID') and stating the default behavior. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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: 'Cancel pending orders to manage exposure or adjust your trading strategy.' It specifies the verb ('cancel') and resource ('pending orders'), and while it doesn't explicitly differentiate from siblings like 'paradex_create_order', the purpose is unambiguous in context.
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, listing five specific scenarios (e.g., 'Remove stale limit orders', 'Quickly reduce market exposure during volatility'). It also clarifies that calling without parameters cancels all orders, offering clear usage rules.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes the tool's purpose and benefits but doesn't disclose behavioral traits like whether it's read-only, potential rate limits, authentication requirements, or what the output format looks like. The description adds value by explaining the utility of schema information but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage guidelines, example use cases) and uses bullet points effectively. While slightly verbose, every sentence adds value by explaining when and why to use the tool. The front-loaded purpose statement is strong.
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 (schema/metadata retrieval) and lack of annotations or output schema, the description does a good job explaining purpose and usage but leaves gaps about behavioral characteristics and output format. It's adequate for understanding when to use the tool but incomplete for understanding what to expect from its execution.
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 'tool_name' parameter. The description doesn't add specific meaning about this parameter beyond implying it's needed to identify which tool's schema to retrieve. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't significantly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('get detailed schema information', 'build precise data filters') and distinguishes it from sibling tools that appear to be data retrieval or trading operations. It explicitly identifies this as a schema/metadata tool rather than a data-fetching tool.
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 with bullet points listing specific scenarios ('when you need to understand fields', 'learn data types', 'build JMESPath queries', 'create filtering expressions'). It also includes example use cases that reinforce appropriate contexts for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool's analytical purpose and use cases but lacks behavioral details like rate limits, authentication requirements, error conditions, or response format. While it mentions what the tool helps achieve (e.g., 'understand market momentum'), it doesn't disclose operational traits such as data freshness, pagination, or performance characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, usage guidelines, explanatory note, and example use cases. It is appropriately sized and front-loaded, starting with the core purpose. Some redundancy exists (e.g., 'Detect large trades' appears in both guidelines and examples), but overall, sentences earn their place by adding value.
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 analytical complexity and lack of annotations or output schema, the description is moderately complete. It thoroughly explains when and why to use the tool but omits behavioral and output details. For a tool with no structured output schema, the description should ideally hint at return values (e.g., trade lists, metrics), but it focuses on use cases instead, leaving gaps in operational 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 all three parameters (market_id, start_unix_ms, end_unix_ms) with descriptions. The description adds no parameter-specific information beyond what the schema provides. It focuses on the tool's purpose and usage, not parameter semantics, meeting the baseline of 3 when schema coverage is high.
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 tool's purpose: 'Analyze actual market transactions to understand market sentiment and liquidity.' It specifies the verb 'analyze' and resource 'market transactions' (trades), distinguishing it from sibling tools like paradex_orderbook (orders) or paradex_account_fills (user-specific fills). The description explicitly contrasts trade data with 'just orders,' highlighting its unique analytical focus.
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 usage guidelines with a bulleted list of when to use this tool: 'Detect large trades...', 'Calculate average trade size...', 'Identify buy/sell pressure imbalances...', etc. It distinguishes this tool from alternatives by noting trade data provides insights 'versus just orders,' helping the agent choose between this and order-related siblings like paradex_orderbook or paradex_orders_history.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a read operation ('Get', 'Retrieves') and describes what information will be returned (available funds, locked funds, total balance), but doesn't mention potential limitations like rate limits, authentication requirements, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with three sentences that each earn their place: stating the purpose, detailing what's retrieved, and explaining the usage context. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool with 100% schema coverage and an output schema, the description provides adequate context. It explains the purpose, what information is returned, and when to use it. The main gap is lack of behavioral details like authentication or rate limits, but the output schema will handle return values.
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 already fully documents the single parameter. The description doesn't add any additional parameter semantics beyond what's in the schema, but doesn't need to since the schema coverage is complete.
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 the current balance') and resource ('of a specific vault'), distinguishing it from sibling tools like paradex_vault_summary or paradex_vault_account_summary by focusing on detailed balance breakdown rather than summary information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('essential for understanding the financial state of a vault before executing trades or withdrawals'), but doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the tool as a read operation ('Get', 'Retrieves'), which implies non-destructive behavior, and mentions that the number of vaults can be large, hinting at performance considerations. However, it lacks details on permissions, rate limits, error handling, or response format, which are important for a tool with 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the core purpose and usage. The JMESPath examples are helpful but slightly lengthy; however, they earn their place by providing practical guidance. Overall, it is efficient with minimal waste, though it could be slightly more streamlined.
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 (4 parameters, no annotations, no output schema), the description is moderately complete. It covers purpose, usage, and parameter semantics well, but lacks behavioral details like response structure, error cases, or authentication needs. Without an output schema, more information on return values would be beneficial, though the description does hint at result formats through examples.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the semantics of vault_address (specific vault vs. all vaults) and jmespath_filter (with examples for filtering, sorting, and limiting). It also implies usage of limit and offset for result management, though not explicitly detailed. This compensates well beyond the schema.
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 tool's purpose with specific verbs ('Get detailed information', 'Retrieves comprehensive details') and resources ('vault' or 'all vaults'). It distinguishes this tool from siblings by focusing on vault details rather than account summaries, balances, positions, or transfers, which are covered by other tools like paradex_vault_summary, paradex_vault_balance, paradex_vault_positions, and paradex_vault_transfers.
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 on when to use the tool: for a specific vault (with address) or all vaults (if no address). It also advises using jmespath_filter to reduce results due to potentially large numbers of vaults. However, it does not explicitly state when not to use this tool or name specific alternatives among siblings, such as paradex_vault_summary for less detailed information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions that the data is 'critical for perpetual futures traders' and discusses use cases, but doesn't disclose behavioral traits like rate limits, authentication requirements, data freshness, or error conditions. The description adds context about what the tool helps with but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, usage guidelines, importance context, and example use cases. It's appropriately sized at 10 sentences, though some redundancy exists between the usage guidelines and example use cases. Every sentence adds value, but it could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (financial data analysis with 3 parameters) and the presence of an output schema, the description provides good context about what the tool does and when to use it. It covers purpose, usage scenarios, and practical applications. With output schema handling return values, the main gap is lack of behavioral transparency details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (market_id, start_unix_ms, end_unix_ms). The description doesn't add any parameter-specific information beyond what's in the schema, such as format examples for market_id or time range constraints. This meets the baseline of 3 when schema coverage is high.
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 tool's purpose as analyzing funding rates for funding arbitrage and understanding holding costs. It specifies the verb 'analyze' and resource 'funding rates', distinguishing it from sibling tools like paradex_account_funding_payments (which likely shows actual payments) and paradex_account_positions (which shows current positions).
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 usage guidelines with a bulleted list of four specific scenarios when to use this tool, including calculating expected payments, finding extreme rates, understanding historical patterns, and evaluating holding costs. It also includes example use cases that reinforce when this tool is appropriate versus alternatives.
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 effectively describes the tool's purpose and use cases but lacks details about authentication requirements, rate limits, error conditions, or response format. The description doesn't contradict annotations (none exist), but doesn't provide comprehensive behavioral context beyond the core functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, importance statement, examples) and front-loads the core purpose. While somewhat verbose with multiple bullet points, each sentence serves a distinct purpose in clarifying usage context, making it efficient rather than wasteful.
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 read-only status check tool with 2 parameters and 100% schema coverage but no output schema, the description provides substantial contextual completeness through detailed usage scenarios and examples. It effectively explains when and why to use this tool, though it could benefit from mentioning response format or error handling to reach full 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 already documents both parameters (order_id and client_id) adequately. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3 for high schema coverage situations.
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 tool's purpose with specific verbs ('check', 'get', 'track') and resource ('detailed status of a specific order'), distinguishing it from siblings like paradex_open_orders (list open orders) and paradex_orders_history (historical orders). It explicitly focuses on individual order monitoring rather than batch operations.
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 when-to-use guidance with a bulleted list of five specific scenarios (e.g., 'Confirm if a particular order was accepted', 'Diagnose issues with order placement'), plus example use cases that clarify context. It implicitly distinguishes from siblings by focusing on individual order status rather than account-level or market data tools.
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 effectively communicates this is a read-only informational tool (implied by 'understand', 'check', 'verify') and provides context about what information is returned. However, it doesn't mention potential limitations like rate limits, authentication requirements, or data freshness.
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 well-structured with clear sections: purpose statement, usage scenarios, importance context, and example use cases. Every sentence adds value without redundancy, and information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has zero parameters, no annotations, but has an output schema, the description provides good context about what information is returned and when to use it. The example use cases are particularly helpful. A 5 would require more explicit differentiation from sibling tools.
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 zero parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the tool's purpose and usage.
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 understanding global parameters affecting all trading activity, with specific examples like fee schedules and trading limits. However, it doesn't explicitly differentiate from sibling tools like paradex_system_state or paradex_filters_model, which might also provide configuration-related information.
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 usage scenarios in a bulleted list, including checking fee schedules, verifying trading limits, understanding exchange-wide parameters, and keeping up with configuration changes. It gives clear context for when to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 effectively describes what information is returned (balances, margin utilization, P&L) but lacks details on data freshness, rate limits, authentication requirements, or error conditions, which are important for a financial tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, example cases) and avoids redundancy. While slightly verbose, every sentence adds value by clarifying different aspects of the tool's application in trading contexts.
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 financial status tool with no annotations and no output schema, the description does a good job explaining what information is returned. However, it lacks details on response format, data granularity (e.g., currency units), or potential limitations, leaving some gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and usage without unnecessary parameter details, meeting the baseline expectation for parameterless tools.
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 tool's purpose with specific verbs ('Get a snapshot') and resources ('account's current financial status and trading capacity'), distinguishing it from siblings like paradex_account_positions or paradex_account_transactions by focusing on overall financial health rather than specific components.
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 through bullet points (e.g., 'Check your current available and total balance') and example use cases (e.g., 'Checking available balance before placing new orders'), clearly differentiating it from alternatives without being misleading.
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 explaining this is a read-only analysis tool for historical data (not real-time), essential for performance analysis and reconciliation. It doesn't mention rate limits or authentication requirements, but covers the core behavioral purpose adequately.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by specific use cases and examples. While slightly longer than minimal, every sentence adds value by clarifying different aspects of when and how to use the tool, with no redundant 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 read-only analysis tool with 3 well-documented parameters and no output schema, the description provides excellent context about what information the tool returns (execution details, prices, PnL, commissions) and how to interpret the results. It could mention the return format, but otherwise covers the essential context well.
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 clear documentation for all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema, but the schema already fully documents market_id, start_unix_ms, and end_unix_ms parameters, meeting the baseline expectation.
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 tool's purpose as analyzing executed trades for performance and execution quality evaluation. It specifies the exact resource (executed trades) and distinguishes from siblings like paradex_account_positions (current holdings) and paradex_orders_history (order history) by focusing specifically on fill-level execution details.
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 usage scenarios in a bulleted list, including when to use it (review trading history, calculate average entry prices, analyze execution quality, track realized PnL, verify order execution) and distinguishes it from alternatives by focusing on executed trades rather than open positions or order status.
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 provides 'current best available prices,' is for 'immediate execution decisions,' offers 'minimal data' compared to full orderbook, and is 'perfect for quick decisions.' It doesn't mention rate limits or authentication needs, but covers the core functionality adequately.
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 and front-loaded with the core purpose in the first sentence. The bulleted lists provide useful elaboration without redundancy. Some repetition exists between the 'Use this tool when' and 'Example use cases' sections, but overall structure is clear and efficient.
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 single-parameter tool with no annotations and no output schema, the description provides excellent context about what the tool returns (best available prices for quick decisions) and when to use it. It could benefit from mentioning the return format or data structure since there's no output schema, but otherwise covers the essential context well.
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% (market_id is fully documented in schema), so the baseline is 3. The description doesn't add any parameter-specific information beyond what the schema provides, but doesn't need to since the schema already covers the single parameter adequately.
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 tool's purpose with specific verbs ('Get the current best available prices') and resource ('for immediate execution decisions'), distinguishing it from sibling tools like paradex_orderbook (full depth) and paradex_market_summaries (broader market data). It explicitly positions this as a minimal-data snapshot tool.
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 ('when you need quick trading decisions without full orderbook depth') and when not to (implied: when full depth is needed). It lists 5 specific use cases and contrasts with alternatives by stating it's 'perfect for quick decisions or when full orderbook depth isn't needed'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's for executing trades (implying mutation/write operations), successful response means orders are queued for execution (not immediate), and users should check order status separately. It mentions risk management aspects but doesn't cover authentication needs, rate limits, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, usage guidelines, primary function, example use cases, and response behavior. It's appropriately sized for a complex trading tool, though the example use cases section could be more concise as some examples overlap with the usage guidelines.
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 complex trading execution tool with 9 parameters, 100% schema coverage, but no annotations or output schema, the description provides good context. It covers purpose, usage scenarios, behavioral expectations, and response interpretation. However, it doesn't address potential errors, authentication requirements, or provide more detail on the queued execution process mentioned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it mentions 'full control over order type, size, price, and execution parameters' and gives example use cases that imply parameter combinations, but doesn't provide additional syntax or format details. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as executing trades on Paradex with precise control over order parameters. It uses specific verbs like 'execute trades' and 'enter a new position' and distinguishes itself from sibling tools by being the primary execution tool, unlike read-only tools like paradex_account_positions or paradex_open_orders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines with a bulleted list of when to use this tool (entering positions, setting limit orders, creating stop-loss/take-profit orders, implementing complex strategies). It also distinguishes from alternatives by stating this is the primary tool for execution decisions, implying other tools are for monitoring or analysis.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it retrieves current market data (implying read-only), specifies that it returns summaries for all markets if 'ALL' or no IDs are given, and mentions JMESPath filtering capabilities. However, it lacks details on rate limits, error handling, or data freshness, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with purpose and usage guidelines. However, it includes repetitive elements (e.g., similar points in usage lists and example use cases) and could be more concise by merging overlapping sections. Most sentences are valuable, but some trimming would improve efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (4 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, parameters, and filtering, but lacks details on output structure (e.g., what fields are returned) and potential limitations like pagination or data latency. This is adequate but has minor 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 all parameters. The description adds some context by explaining the default behavior with 'ALL' market IDs and providing JMESPath examples, but it doesn't add significant meaning beyond what the schema provides (e.g., no extra syntax or format details). This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/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 ('identify', 'get', 'retrieves') and resources ('markets', 'market summary information'). It distinguishes itself from sibling tools by focusing on market summaries rather than account data, orders, or other market functions, making its scope explicit.
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, listing four specific scenarios (e.g., 'Find the most active markets by volume', 'Discover markets with significant price movements'). It also includes example use cases and references an alternative tool ('paradex_filters_model') for filtering, offering clear context for application.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the tool's purpose (monitoring/read-only) and what information it returns (positions, P&L, liquidation prices, etc.), but doesn't specify behavioral traits like rate limits, authentication requirements, error conditions, or pagination. It adequately describes the tool's function but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, rationale, examples) and front-loaded key information. It's appropriately sized for the tool's complexity, though slightly verbose in listing multiple similar examples (e.g., 'monitoring unrealized profit/loss' appears twice). Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, read-only monitoring function), the description is quite complete. It explains what the tool does, when to use it, and provides examples. With an output schema present (per context signals), the description doesn't need to detail return values. The main gap is lack of behavioral transparency details (auth, limits, errors).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (single parameter 'vault_address' is well-described in schema). The description doesn't add parameter-specific semantics beyond what the schema provides, but with only one parameter and high schema coverage, the baseline is strong. No additional parameter context is needed.
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 tool's purpose with specific verbs ('monitor', 'track', 'manage') and resources ('active trading positions', 'vault'), distinguishing it from siblings like paradex_account_positions (which appears to be for individual accounts rather than vaults). It explicitly lists what the tool provides: complete view of open positions, P&L monitoring, liquidation prices, margin requirements, etc.
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 usage guidelines with a dedicated 'Use this tool when you need to:' section listing five specific scenarios, plus example use cases. It implicitly distinguishes from siblings by focusing on vault-level positions rather than account-level (e.g., vs. paradex_account_positions), though it doesn't name alternatives directly.
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: it discloses that results can be large (performance implication), explains the optional filtering mechanism with examples, and describes the return content (balance, positions, etc.). It doesn't mention rate limits or authentication needs, but covers key behavioral aspects for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first paragraph states the core purpose, the second elaborates on content, and the rest provides practical guidance with examples. The JMESPath examples are necessary for clarity but make it slightly longer; overall, each section earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 4 parameters with good schema coverage, the description is quite complete: it explains what the tool does, when to use it, behavioral traits like result size, and parameter usage with examples. It could mention error cases or exact output structure, but for a read tool with high schema coverage, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantics of vault_address (specific vs. all vaults) and jmespath_filter (with multiple examples for filtering, sorting, transforming), which enhances understanding beyond the schema's technical descriptions. It doesn't detail limit/offset but those are straightforward.
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 'summary of a specific vault or all vaults', specifying it retrieves comprehensive information including balance, positions, recent activity, and performance metrics. It distinguishes from siblings like paradex_vaults (likely just listing) and paradex_vault_balance/positions (specific components) by emphasizing a holistic overview.
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: use when needing a high-level overview of vault state, with guidance to use jmespath_filter for efficiency due to potentially large result sets. It doesn't explicitly state when not to use it or name specific alternatives among siblings, but the context implies it's for summary vs. detailed components.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's function as historical tracking for auditing purposes, implying read-only behavior without destructive actions. However, it doesn't specify data format, pagination, or rate limits, leaving some behavioral aspects unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by usage scenarios and example use cases. While slightly verbose, every section adds value by clarifying context and applications. It could be more concise by combining some bullet points, but overall it's efficiently organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (historical data retrieval), no annotations, and the presence of an output schema (which handles return values), the description provides good contextual completeness. It explains the tool's purpose, usage scenarios, and value proposition, though it could benefit from mentioning data recency or limitations.
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, clearly documenting the single required parameter 'vault_address'. The description doesn't add any additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 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 tool's purpose as tracking deposit and withdrawal history for auditing and reconciliation. It specifies the verb 'track' and resource 'deposit and withdrawal history', distinguishing it from sibling tools like paradex_vault_balance (which likely shows current balance) or paradex_account_transactions (which might be for general account activity).
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 through a bulleted list of scenarios (e.g., verifying deposits, tracking withdrawals, auditing fund flow). It implicitly distinguishes from siblings by focusing on vault-specific transfer history rather than general account data or current balances, though it doesn't explicitly name alternatives.
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?
Annotations already declare readOnlyHint=true, indicating this is a safe read operation. The description adds valuable context beyond this by explaining the tool's role in order management, avoiding duplicate trades, and providing example use cases like checking partial fills and identifying stale orders. It doesn't contradict the read-only annotation.
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 well-structured with clear sections: purpose statement, bulleted usage guidelines, importance explanation, and example use cases. Every sentence adds value without redundancy, and it's front-loaded with the core purpose.
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 read-only tool with full schema coverage and no output schema, the description provides excellent context about what the tool returns (active orders with execution status, prices, quantities) and why it's useful. It could slightly improve by explicitly mentioning pagination behavior (implied by limit/offset parameters), but it's largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the three parameters (market_id, limit, offset). The description doesn't add any parameter-specific information beyond what's in the schema, but it doesn't need to since the schema coverage is complete. Baseline 3 is appropriate.
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 tool's purpose as monitoring active orders to track execution status and manage trading strategy. It uses specific verbs like 'monitor', 'track', and 'manage' and distinguishes itself from siblings like paradex_orders_history (historical orders) and paradex_order_status (single order status).
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 with a bulleted list of specific scenarios (e.g., 'Check which of your orders are still pending execution', 'Determine which orders might need cancellation or modification'). It also implicitly distinguishes from alternatives like paradex_orders_history by focusing on active/pending orders rather than historical ones.
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. It effectively discloses behavioral traits: it's a read-only operation for monitoring and assessment (implied by 'get' and 'check'), provides essential risk metrics, and informs decision-making. However, it lacks details on rate limits, authentication needs, or error conditions, which would elevate the score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, example cases) and front-loaded key information. It avoids redundancy, but could be slightly more concise by integrating some bullet points into prose without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (single parameter, read-only operation), the description is complete. It covers purpose, usage guidelines, and behavioral context thoroughly. With an output schema present, it doesn't need to explain return values, and the absence of annotations is compensated by the detailed description.
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 'vault_address'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema handles parameter documentation adequately.
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 tool's purpose with specific verbs ('get a comprehensive overview') and resource ('vault's trading account status'), distinguishing it from siblings like paradex_account_summary (general account) and paradex_vault_summary (vault-level summary). It explicitly targets vault-specific account health and trading metrics.
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 usage scenarios in a bulleted list, including when to use it (e.g., 'before placing new orders', 'during market volatility') and distinguishes it from alternatives by focusing on consolidated account performance for risk management, unlike sibling tools that handle specific aspects like positions, transactions, or orders.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it retrieves comprehensive market details, explains the default behavior when no market IDs are given, mentions the ability to filter/sort/limit results using JMESPath, and provides examples of use cases. However, it lacks details on rate limits, error handling, or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with a clear purpose statement and usage guidelines. It uses bullet points and examples effectively, though it could be slightly more concise by integrating the JMESPath explanation more tightly. Every sentence adds value, such as clarifying default behaviors and providing actionable examples.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (4 parameters, no output schema, no annotations), the description is quite complete. It covers the tool's purpose, usage, parameter semantics, and behavioral aspects like filtering and default returns. However, without an output schema, it could benefit from more details on the structure of returned market data (e.g., specific fields like 'volume_24h' mentioned in examples).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the semantics of 'market_ids' (e.g., using 'ALL' returns all markets), detailing 'asset_kind' values ('PERP' or 'PERP_OPTION'), and providing practical examples for 'jmespath_filter' with JMESPath expressions. It also clarifies the purpose of filtering and limiting results beyond the schema's technical 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 tool's purpose with specific verbs ('find markets', 'get detailed market specifications') and distinguishes it from siblings by focusing on market discovery and specification retrieval rather than account operations, trading, or system functions. It explicitly lists use cases like finding tick sizes and comparing contract specifications.
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 through a bulleted list (e.g., 'Understand exact tick sizes', 'Find all markets for a specific asset') and distinguishes it from alternatives by mentioning the 'paradex_filters_model' tool for obtaining filters. It also clarifies that specifying 'ALL' or no market IDs returns all markets.
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 communicates that this is a read-only analysis tool (implied by 'analyze' and 'assess'), describes its value for trade execution optimization, and mentions practical applications like slippage estimation. However, it doesn't explicitly state rate limits, authentication requirements, or data freshness.
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 well-structured with clear sections: a purpose statement, specific use cases in bullet points, and example applications. Every sentence adds value without redundancy. The front-loaded purpose statement immediately communicates the tool's function, followed by practical guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (market analysis with 2 parameters), the description provides excellent context about why and when to use it. With an output schema present, the description correctly focuses on purpose and usage rather than return values. The combination of purpose statement, usage guidelines, and example cases creates a complete picture for an AI agent.
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 parameter-specific information beyond what's in the schema. It focuses on the tool's purpose and usage rather than parameter details, which is appropriate given the comprehensive 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 tool's purpose as analyzing market depth and liquidity for order optimization, using specific verbs like 'analyze' and 'optimize'. It distinguishes from siblings like paradex_bbo (best bid/offer) and paradex_markets by focusing specifically on orderbook depth analysis rather than basic market data or execution actions.
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 with four bullet points covering specific scenarios like assessing liquidity before large orders, identifying support/resistance levels, determining optimal limit prices, and detecting order imbalances. It implicitly distinguishes from execution tools like paradex_create_order by focusing on analysis rather than order placement.
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 describing the tool's purpose (verification/checking), context (operational status, maintenance periods, clock sync), and importance (critical trades, API issue diagnosis). It doesn't mention rate limits, authentication needs, or specific error conditions, but provides substantial behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose statement, usage bullet points, importance context, example use cases). Every sentence adds value without redundancy, and the information is front-loaded with the core purpose stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema exists), the description provides comprehensive context about when and why to use this tool. It covers purpose, usage scenarios, importance, and examples, which is complete for a status-checking tool with no parameters.
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 zero parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on usage context and scenarios.
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 tool's purpose with specific verbs ('verify', 'check', 'confirm') and identifies the resource ('exchange', 'Paradex'). It distinguishes from siblings by focusing on system operational status rather than trading, account, or market data functions.
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 when-to-use guidance with bullet points listing specific scenarios (before trades, during unexpected behavior, before maintenance checks, for clock sync). It also includes 'especially important' context and example use cases that reinforce appropriate usage contexts.
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

MCP Paradex Server MCP server – quality and maintenance score on Glama

Copy to your README.md:

[![MCP Paradex Server MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/Habinar/mcp-paradex-py/badges/card.svg)](https://glama.ai/mcp/servers/Habinar/mcp-paradex-py)

Score Badge

Copy to your README.md:

[![MCP Paradex Server MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/Habinar/mcp-paradex-py/badges/score.svg)](https://glama.ai/mcp/servers/Habinar/mcp-paradex-py)