Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Hyperliquid MCP Server Show me my open positions and unrealized PnL"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
The first MCP server for DeFi perpetual futures trading. Let AI agents trade on Hyperliquid — the #1 decentralized derivatives exchange ($50B+ weekly volume).
Trade perps, check positions, manage risk — all through natural language via Claude, GPT, or any MCP-compatible AI agent.
Tool | Description |
| Wallet balance, margin, withdrawable funds |
| All available perpetual futures markets |
| Price, funding rate, OI, 24h volume |
| Live orderbook with configurable depth |
| All pending orders |
| Open positions with PnL & liquidation price |
| Limit or market orders |
| Cancel by order ID |
| Set leverage (cross or isolated) |
| Close positions (market or limit) |
Related MCP server: hyperliquid-mcp
pip install -e .Or install dependencies directly:
pip install "mcp[server]" hyperliquid-python-sdk python-dotenvcp .env.example .envEdit .env:
HYPERLIQUID_PRIVATE_KEY=your_private_key_here
HYPERLIQUID_WALLET_ADDRESS=0xYourAddress
HYPERLIQUID_TESTNET=true⚠️ Start with testnet! Set
HYPERLIQUID_TESTNET=truefor paper trading.
hyperliquid-mcp
# or
python -m hyperliquid_mcp.serverAdd to your claude_desktop_config.json:
{
"mcpServers": {
"hyperliquid": {
"command": "python",
"args": ["-m", "hyperliquid_mcp.server"],
"cwd": "/path/to/hyperliquid-mcp",
"env": {
"HYPERLIQUID_PRIVATE_KEY": "your_key",
"HYPERLIQUID_WALLET_ADDRESS": "0xYourAddress",
"HYPERLIQUID_TESTNET": "true"
}
}
}
}Or if installed via pip:
{
"mcpServers": {
"hyperliquid": {
"command": "hyperliquid-mcp",
"env": {
"HYPERLIQUID_PRIVATE_KEY": "your_key",
"HYPERLIQUID_WALLET_ADDRESS": "0xYourAddress",
"HYPERLIQUID_TESTNET": "true"
}
}
}
}Once connected, try asking your AI agent:
"What's the current BTC funding rate on Hyperliquid?"
"Show me the ETH orderbook, top 5 levels"
"Set leverage to 5x on SOL and buy 10 SOL at market"
"What are my open positions and total PnL?"
"Close my ETH position at market price"
"List all available markets and their max leverage"
Never commit your .env file — it contains your private key
Start with testnet — always test with paper money first
Review orders before confirming — AI agents can make mistakes
Private keys are only used locally — never transmitted except to Hyperliquid's API
Python 3.10+
A Hyperliquid wallet (testnet or mainnet)
An MCP-compatible client (Claude Desktop, etc.)
MIT
Cancel an open order by order ID
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol | |
| order_id | Yes | Order ID to cancel |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, description fails to disclose error conditions, idempotency, side effects, or what happens to partially filled orders.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise at 6 words; single sentence is front-loaded with action verb and contains no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Minimal viable description for a simple operation; lacks return value documentation (no output schema) and edge case handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with adequate descriptions; tool description adds no additional parameter context beyond repeating 'order ID'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb (cancel) and resource (open order by ID), implicitly distinguishes from close_position via 'order' vs 'position' terminology.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use versus alternatives (e.g., close_position for executed trades) or prerequisites (e.g., checking open orders first).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close an open position (market close or limit close)
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol | |
| price | No | Limit price to close at (omit for market close) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses support for both market and limit close behaviors, but lacks information on error cases (e.g., no open position) or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, efficient sentence that front-loads the action with zero redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for the simple 2-parameter input, though missing error handling details given no output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so baseline applies; description adds minimal context beyond schema but clarifies the market/limit dichotomy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool closes open positions and distinguishes between market and limit close modes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to select this tool versus siblings like place_order, or when to prefer market vs limit close.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get wallet balance, margin summary, and withdrawable funds
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure. It compensates for the missing output schema by listing the specific data categories returned (wallet balance, margin summary, withdrawable funds), but omits critical operational details such as rate limits, data freshness (real-time vs. cached), or scope (all sub-accounts vs. specific ones).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of a single, efficient sentence with zero wasted words. It is appropriately front-loaded with the verb and immediately specifies the returned data types, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero parameters) and lack of output schema, the description adequately compensates by enumerating the specific financial metrics returned. It successfully communicates the tool's scope for an account information fetcher, though it could clarify whether the data covers all account types or requires specific permissions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema contains zero parameters, establishing a baseline score of 4. The description appropriately makes no parameter claims, as there are none to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and clearly enumerates the three data categories retrieved (wallet balance, margin summary, withdrawable funds). This distinguishes it from siblings like get_market_info (market data) and get_open_orders (order data), though it could more explicitly contrast with get_positions regarding margin data overlap.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_positions (which may also return margin-related data) or prerequisites such as authentication requirements. It states what it does but not when an agent should invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current price, funding rate, open interest, and 24h volume for a perpetual market
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol (e.g. BTC, ETH, SOL) |
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 'current' data but fails to disclose cache behavior, rate limits, authentication requirements, or error handling (e.g., invalid symbols). The term 'perpetual' hints at funding rate mechanics but lacks explicit behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with zero waste. Front-loaded with the action verb, immediately followed by the four specific data fields. Every word earns its place—no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description compensates well by enumerating the four specific return fields. For a single-parameter read operation, this is adequate coverage, though mentioning data freshness or response format would improve it further.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the parameter is well-documented in the schema itself. The description adds contextual alignment by specifying 'perpetual market,' which clarifies the domain for the symbol parameter, but does not add syntax details or format constraints beyond the schema examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description provides a specific verb ('Get'), identifies the resource ('perpetual market'), and explicitly lists the four data points returned (price, funding rate, open interest, 24h volume). This clearly distinguishes it from siblings like get_orderbook (depth data) and get_account_info (user data).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the description implies usage by listing specific metrics, it provides no explicit guidance on when to use this versus list_markets (to discover symbols) or get_orderbook (for trading depth). No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all open orders for the connected wallet
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses read-only behavior ('List') and authentication scope ('connected wallet'), but omits rate limits, pagination behavior, or what 'open' specifically means (unfilled vs pending cancellation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with verb, zero waste. Appropriate length for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a zero-parameter read operation. Mentions 'connected wallet' establishing scope, but lacks return value description (relevant given no output schema exists). Missing clarification on what constitutes an 'open' order in this trading context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters present. Per rubric baseline for 0-param tools is 4. The description correctly implies no filtering parameters are accepted by stating 'all open orders'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb 'List' with clear resource 'open orders' and scope 'connected wallet'. It implicitly distinguishes from siblings like get_positions (filled trades) and get_orderbook (market depth) via standard trading terminology, though explicit differentiation is absent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use versus alternatives (e.g., get_positions vs open orders) or prerequisites. The agent must infer usage solely from the tool name and trading context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the orderbook (bids and asks) for a perpetual market
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol (e.g. BTC, ETH) | |
| depth | No | Number of price levels (default 10) |
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 implies a read-only operation via 'Get' but fails to disclose latency characteristics, authentication requirements, error handling for invalid symbols, or data freshness guarantees.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence of nine words that immediately communicates the core function without redundancy or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple 2-parameter schema with complete coverage and no output schema, the description is minimally adequate. It mentions 'bids and asks' hinting at return structure, but lacks explicit return value documentation or behavioral context expected when no output schema is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds slight value by specifying 'perpetual market' context for the symbol parameter, though it does not elaborate on depth behavior beyond the schema's default value description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves the orderbook with specific mention of 'bids and asks' for a 'perpetual market'. It distinguishes from siblings like get_account_info or get_positions by specifying the resource type, though it could explicitly differentiate from get_market_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_market_info, nor does it mention prerequisites such as valid market symbols or rate limit considerations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all open positions with unrealized PnL, leverage, and liquidation price
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses what data is returned (unrealized PnL, leverage, liquidation price), compensating for missing output schema. However, it fails to declare safety properties (read-only/idempotent) or rate limits that agents need for mutation-risk assessment.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, dense sentence with zero waste. Front-loaded action verb, followed by resource scope, followed by return value specification. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema exists, the description effectively documents return value structure by listing key fields (unrealized PnL, leverage, liquidation price). Adequate for a zero-parameter read operation, though explicit read-only declaration would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has zero parameters, establishing baseline of 4. Description appropriately requires no parameter elaboration since input schema is empty.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb 'List' + resource 'open positions' clearly defines scope. Explicitly distinguishes from sibling get_open_orders by using 'positions' vs 'orders', and from close_position via 'List' (read) vs 'close' (write). The inclusion of return fields (unrealized PnL, leverage, liquidation price) further clarifies this retrieves active trading exposure data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implicit guidance through specific resource naming (distinguishes positions from orders/account), but lacks explicit when-to-use guidance versus alternatives like get_account_info or set_leverage. No explicit prerequisites or exclusions stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available perpetual futures markets on Hyperliquid
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. 'List' implies read-only, non-destructive behavior, but description omits rate limits, caching behavior, or response structure (array of symbols vs. full objects) that would help an agent plan invocation strategy.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single 9-word sentence with action-first structure. No redundant phrases or boilerplate. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a zero-parameter discovery tool. While no output schema exists, the description sufficiently conveys the tool's role. Minor gap: does not hint at return format (e.g., 'returns market symbols') which would help agent interpret results without invoking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters present, meeting the baseline score of 4 per rubric. Description correctly implies no filtering is available (returns 'all' markets), which aligns with the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear specific verb 'List' with explicit resource 'perpetual futures markets' and scope 'all available on Hyperliquid'. Distinguishes from sibling get_market_info by implying bulk retrieval vs. specific details, and clearly separates from trading actions like place_order.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implied usage context (market discovery/initialization) but lacks explicit when-to-use guidance or comparison with get_market_info. Does not clarify whether to use this for trading preparation versus runtime market monitoring.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Place a limit or market order on Hyperliquid perps
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol (e.g. BTC, ETH) | |
| side | Yes | Order side | |
| size | Yes | Order size in base asset units | |
| price | No | Limit price (required for limit orders) | |
| order_type | No | Order type (default: limit) | limit |
| reduce_only | No | Reduce-only order (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description fails to disclose side effects, failure modes (insufficient margin), confirmation behavior, or that orders persist until filled/cancelled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise single sentence, front-loaded with key action; appropriately sized though minimal given operation complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Insufficient for a financial trading tool with 6 parameters; missing output behavior, error conditions, and relationships to cancel_order/close_position despite no output schema existing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage establishing baseline; description adds no parameter relationships (e.g., price only for limit) or domain context beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb and resource (place orders on Hyperliquid perps), distinguishes from siblings (cancel/close/get operations) by specifying 'place' and order types, though lacks explicit differentiation from close_position.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use limit vs market, when price is required, or prerequisites like leverage settings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set leverage for a perpetual market
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | Market symbol | |
| leverage | Yes | Leverage multiplier (e.g. 5, 10, 20) | |
| is_cross | No | Use cross margin (default: true) |
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 but fails to mention critical trading implications: whether this affects liquidation prices, if changes apply retroactively to existing positions, validation limits on leverage values, or that this is a state-mutating operation with financial risk.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely brief at 6 words. While front-loaded and without filler, this level of brevity is inappropriate for a high-stakes trading operation, omitting necessary warnings and behavioral context that should earn their place in the description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a financial tool that modifies margin requirements and liquidation risk, the description is dangerously incomplete. It lacks disclosure of side effects, error conditions (e.g., excessive leverage), or output expectations. No output schema exists to compensate for these gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description mentions 'perpetual market' which loosely contextualizes the 'symbol' parameter, but adds no semantic detail beyond the schema's own descriptions (e.g., doesn't explain cross vs isolated margin implications or valid leverage ranges).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the core action ('Set leverage') and scope ('perpetual market'), using a specific verb and resource. However, it lacks differentiation from siblings (though none are leverage-related) and doesn't clarify whether this sets account default or position-specific leverage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance provided on when to use this tool versus alternatives, prerequisites (e.g., requiring an open position), or sequencing (whether to set before or after placing orders). The description stands alone without workflow context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0cancel_orderclose_positionget_account_infoget_market_infoget_open_ordersget_orderbookget_positionslist_marketsplace_orderset_leverageScored across 10 tools
Each tool has a clearly distinct purpose in the trading lifecycle. Orders (place, cancel, get_open) are cleanly separated from positions (get, close), and market data tools (list_markets, get_market_info, get_orderbook) serve different information needs without overlap.
Excellent consistency throughout. All tools use snake_case with clear verb_noun or get_noun patterns (e.g., place_order, get_account_info, list_markets). The verb choices (place, cancel, close, get, list, set) are precise and predictable.
Ten tools is a reasonable scope for active trading operations, covering account, market data, orders, and positions. While the count is appropriate, a comprehensive trading surface might additionally include order history or modification tools, making it slightly lean.
Covers the core trading lifecycle well (account balance, market data, order management, position closing). Minor gaps include order history/fills, the ability to modify existing orders, and funding rate history—though agents can work around these by canceling/replacing orders and using current market data.
Hyperliquid - 2 tools for perpetuals, options, and position data
Non-custodial Hyperliquid perp trading: live markets, account state, user-armed order execution
Polymarket + Hyperliquid + macro for AI agents. 38 tools, signal backtest, SSE streaming. Free tier.
Version 2.8.0. HyperNatt Terminal: liquidation radar, Hyperliquid execution context and Li.Fi cross-chain swap for AI agents. BTC ETH SOL BNB XRP HYPE ZEC. Before an order: estimate depth, VWAP, spread and fees for its size. Between checks: compare liquidity and costs with the previous baseline. After execution: reconcile supplied fills. Read-only data, no custody or order submission. 6 tools, v2.8.0; call get_agent_manifest first. Radar and each execution-context call cost 0.001 USDC via x402 Base/Solana or eligible credits; manifest and MCP swap quote are free (on-chain swap fees apply). Daily MCP trial: one free call per paid tool and per token per client each UTC day. Four tools x seven tokens = up to 28 independent trials; then 0.001 USDC per call. Read trial_policy_v2 and free_tier_status_v1 on the same MCP connection for current availability. A zero daily_cap is the separate credit pool, not the intro allowance. Full platform: https://hypernatt.com. Docs: github.com/DIALLOUBE-RESEARCH/hypernatt-terminal.