A Hyperliquid MCP server that drives a real backtest engine.
Keel is a Hyperliquid MCP server that gives Claude, Cursor, and any MCP-capable agent 22 MCP tools backed by a real backtest engine. Compose a typed strategy graph, run a deterministic backtest against real Hyperliquid funding and price, deploy the same compiled artifact live.
The agent surface for Hyperliquid is mostly empty.
Three patterns dominate today, and none of them give an agent enough surface to do real systematic work. Keel is the one that ships an engine behind the MCP.
The handful of HL MCP servers on GitHub wrap the Hyperliquid REST API — they expose a price endpoint, an OI endpoint, maybe an order-placement endpoint. There is no backtest engine underneath. The agent stops at "here is the current funding rate" instead of "here is a backtested funding-carry strategy you can deploy."
Keel exposes 22 MCP tools backed by a deterministic backtest engine, a typed 182-component DSL, and a live execution path. The agent composes a strategy, backtests it on real Hyperliquid funding + price, and hands back a tearsheet URL.
Every developer who wants Claude on Hyperliquid ends up writing their own MCP server: a Python script that wraps the SDK, glued to one broker, with a personal API key in the config and no path to live execution. Fragile, undocumented, single-user.
pipx install keel-trade ships a maintained MCP binary, browser OAuth 2.1 + PKCE auth, agent-mode detection across Claude / Cursor / Windsurf / Codex, and the same compiled-artifact path live trading already uses.
Coinrule, 3Commas, Bitsgap and the older no-code builders predate MCP entirely. They run hosted rule engines behind a web UI; the agent has no surface to drive, and the rule language does not survive contact with a perp venue’s funding mechanics.
Keel’s surface is the MCP server — the same surface a person uses through the CLI or the web app. The agent does not run a separate bot; it composes a strategy that the engine executes against real Hyperliquid fills.
Under the hood
Structured strategy engine
Strategies are composable pipelines of typed components. The system validates every connection at edit time — errors caught before you backtest, not after you deploy.
AI built on the same system
AI doesn’t generate code — it composes from the same components you use. It understands valid connections, constraints, and trade-offs. Every strategy it builds is structurally valid.
Detailed backtest reports
Sharpe, Sortino, max drawdown, win rate, trade-by-trade logs. Compare runs side by side. Real fee and slippage modeling.
Version control for strategies
Every edit creates a new version. Compare any two versions side by side. Tag releases, restore previous versions, fork strategies. Your full history, always recoverable.
Auditable execution logs
Every live run is logged — what the strategy calculated, what orders executed, what filled. Full transparency.
Non-custodial by design
Your keys never touch our servers. Keel uses Hyperliquid’s native delegation. Sign once, revoke anytime.
Two commands, then talk to your agent.
The Keel MCP is a local stdio server bound into the keel binary. pipx install keel-trade once; the rest of setup happens inside the agent on the first prompt.
Two commands, then connect
Register the stdio MCP with Claude Code. Auth happens from inside Claude on first prompt.
mcp.json registration
Same binary, registered through Cursor’s MCP config file in the project root.
Token auth (no browser)
For CI, SSH, Codespaces, or WSL — anywhere the agent and a browser are not on the same machine.
A real run, composed by the agent.
Claude composed a funding-carry strategy by calling keel_components_search, keel_strategy_compose, and keel_backtest_run through the MCP. Every number below comes from that single agent-driven flow.
Funding-carry on Hyperliquid perps
Claude composed a funding-carry strategy via the MCP server — short the funding-payers, long the funding-receivers, scaled by realised volatility — then ran a backtest and returned this share URL. Reproduce the same prompt + flow in your own agent. Period: 2024-08-15 → 2026-04-30 (20 mo).
Verified Keel backtest. Past performance is not indicative of future returns.
Where each MCP option actually sits.
How the alternatives compare. The open-source HL MCP servers on GitHub are useful read-only price wrappers; the SDK is a fine primitive; Coinrule is a no-code bot builder that predates MCP. Keel is the only surface with a real backtest engine behind it and a path to live.
| Feature | Keel MCP | Wrapper MCPs (edkdev, kukapay, mektigboy) | HL Python SDK | Coinrule |
|---|---|---|---|---|
| MCP tools exposed | 22 MCP tools | 5-15 read-only tools | n/a (REST API) | n/a (web only) |
| Backtest engine | Deterministic, Hyperliquid-native, real fees + funding | None | DIY | Backtester limited to spot rules |
| Backtest-to-live parity | Yes — same compiled artifact deploys live | No | No (research only) | Separate engines |
| Typed component library | 182 components, validated at compose time | — | — | — |
| Live execution on HL perps | Yes — non-custodial via HL delegation | Order-placement only, no strategy mgmt | DIY | Spot-focused |
| Auth | OAuth 2.1 + PKCE (keel auth login) | Personal API key, manual | Personal API key | Account-based |
| Pricing | Free to start; paid plan for live | Free (DIY) | Free (DIY) | $35/mo+ |
Competitor surfaces summarized from public GitHub READMEs as of 2026-05-20. “DIY” means the primitive exists but the user wires it up.
Common questions
What is an MCP server, and why does it matter for Hyperliquid?
Model Context Protocol (MCP) is the open standard that lets agents like Claude and Cursor call external tools through a typed surface — request a backtest, query components, list accounts — instead of scraping a web UI. Hyperliquid is the perp-focused venue where systematic crypto trading actually clears; the combination matters because every other agent-ready research stack (QuantConnect, Lumibot, AlphaSquared) skips Hyperliquid, and the handful of open-source HL MCP servers on GitHub stop at price-data wrappers.
How do I install the Keel MCP with Claude Code?
Two commands: pipx install keel-trade (or uv tool install keel-trade), then claude mcp add keel -- keel mcp serve. That registers the local stdio MCP with Claude Code. Open Claude and say "Connect to Keel" — the agent calls keel_auth_login, your browser opens to app.usekeel.io for OAuth 2.1 + PKCE consent, tokens land in ~/.keel/config.yaml, and you stay logged in for 30 days. Cursor, Windsurf, and Codex use the same binary with their own mcp.json registration.
What tools does the Keel MCP expose to my agent?
The default toolset spans four domains. Status + auth: keel_status, keel_auth_login, keel_doctor, keel_help. Strategy lifecycle: keel_strategy_compose, keel_strategy_fork, keel_strategy_diff, keel_strategy_get, keel_strategy_search, keel_strategy_delete, keel_strategy_memory_read, keel_strategy_memory_write. Backtest + sharing: keel_backtest_run, keel_backtest_summarize, keel_share_create, keel_audit_list_last, keel_audit_replay. Components + discovery: keel_components_search, keel_components_compose_help. Plus keel_accounts_list. Live-trading tools (deploy, pause, stop) are opt-in via the live scope.
Does the agent run my account autonomously?
No. The agent helps you build the strategy; the compiled strategy runs it. Claude (or Cursor, or Codex) collaborates with you to compose a typed strategy graph and run backtests. Once you deploy, the compiled strategy artifact runs on its own schedule against your Hyperliquid account — the agent is not in the execution loop. Live trading is non-custodial via Hyperliquid native delegation, gated by an OAuth live scope plus a local arming step. Two locks, both required.
What data does the backtest run on?
Hyperliquid 15-minute bars and 1-hour funding rates, the same series the live execution path reads. History depth varies per asset — HYPE starts 2024-12-05, BTC, ETH, and SOL go back further. The verified funding-carry backtest spans 2024-08-15 → 2026-04-30; that share URL is the concrete example of what the engine produces. Funding accrues hourly into the equity curve and is decomposed so you can see price-only return, funding return, and combined return separately.
How does this compare to the open-source HL MCP servers on GitHub?
The comparison table above has the details — short version: the wrappers (edkdev, kukapay, mektigboy and similar) expose 5-15 read-only price and account endpoints. There is no backtest engine behind them, no typed component graph, no path from research to live. Keel is the engine those wrappers would call if the engine existed.
Keep exploring
Keel MCP — product page
The full product page for the Keel MCP server. Install matrix, tool reference, prompts that work, demo recording.
Claude on Hyperliquid
Sibling pillar — the Claude-driven workflow on Hyperliquid: compose, backtest, deploy. Same engine, agent-first framing.
Backtest Hyperliquid strategies
The backtest-engine pillar. Real fees, real funding, decomposed P&L, ~220 perps. The engine the MCP drives.