What is agentic trading?

Loose definition (autonomous-bot frame). An LLM is in the runtime loop. It reads market data, decides when to enter and exit, sizes positions, and places orders. The user grants the agent ongoing access to their funds and trusts it to make trading decisions in real time. This is what most "AI trading bot" pitches mean. It is also the failure mode most prone to blowing up — LLMs hallucinate deterministic math; they have no inherent grasp of funding accrual, fee terms, or position-sizing kelly; they generate plausible-looking entries that have no statistical edge underneath. The autonomous wallet bots in this space (Senpi, Katoshi, OpenClaw, and various Telegram-distributed bots) have short track records.

Tight definition (strategy-builder frame). An LLM is at design time only. It collaborates with you to express a thesis as a typed component graph. The graph compiles to a deterministic artifact. The artifact runs in a backtest engine; the same artifact deploys live with bit-for-bit parity. The LLM does what LLMs are actually good at (composition, refactoring, summarization). The engine does what engines are good at (deterministic math, exact bookkeeping, reproducibility). The agent is not in the runtime.

Keel uses the tight definition. When you read "agentic trading on Keel", read it as: Claude helps you build a strategy; the compiled strategy trades.

Three frames in the wild right now. Each has different failure modes; understanding them is how you decide which to use.

1. Autonomous-bot agentic. The LLM makes runtime decisions on your funds. Products: autonomous wallet bots such as Senpi, Katoshi, OpenClaw, and various Telegram-distributed bots. Risk surface: hallucination at trade time (the model generates a position the math does not support), no deterministic backtest (the same prompt run twice produces different outputs), no funding model (perp carry is invisible to the LLM), and no audit trail you can replay deterministically. The category exists; the track records are short.

2. Code-generator agentic. The LLM writes Python that calls a broker REST API directly. Output: a bespoke trading script per strategy. Risk surface: drift between research script and live script (subtle differences in how prices are read, how funding is accrued, how slippage is modeled produce backtest-to-live divergence). No engine underneath to enforce consistency. Every strategy is its own snowflake. Works for one-off experiments; does not scale to a research practice.

3. Strategy-builder agentic. The LLM composes a typed strategy graph via MCP. The engine runs a deterministic backtest. The compiled strategy artifact (the same one that backtested) deploys to live execution with bit-for-bit parity. The agent is out of the runtime. Risk surface: the agent can still propose a bad strategy, but the engine math is exact; the live execution is the artifact you signed off on; and any discrepancy is a code bug, not a hallucination.

The split is empirical. LLMs are sharp at things that have lots of valid solutions: prose, code composition, refactoring, summarization, "what does this do?" explanations. LLMs hallucinate on things that have a single correct answer: arithmetic, deterministic state, exact accounting. Trading hits both categories. Composing a thesis (what signals to combine, what regime to gate on, what to vol-target) is the soft side — there are many reasonable answers, and a good LLM can iterate quickly. Computing P&L is the hard side — there is exactly one correct answer, and an LLM that hallucinates a fill price by 5 bps is breaking your live execution.

The strategy-builder frame is the only one that lines up cleanly with this split. Soft work to the LLM; hard work to the engine. The other two frames put the LLM in charge of work it is not equipped for.

A user asks an MCP-capable agent (Claude Code, Cursor, Codex CLI — any of them) to compose a funding-carry strategy with a funding-level regime gate, and backtest it from August 2024 to April 2026. The agent searches the component library, finds the carry signal and the funding-level regime component, composes the typed DSL graph, submits it via keel_strategy_compose, and triggers keel_backtest_run.

The engine runs deterministically. Result: Sharpe 2.17, +79.6% total return, −9.7% max drawdown, over 2024-08-15 to 2026-04-30 on Hyperliquid perps with real funding, real fees, and modeled slippage. Full tearsheet: app.usekeel.io/share/gDXjURKqWPs8CZ4eXdqAI.

The crucial point: the agent did not compute the Sharpe. The agent composed the strategy. The engine computed the Sharpe from a serialized strategy artifact. If you re-run the same artifact, you get the same Sharpe — bit-for-bit. If you deploy the same artifact live, it places the same trades the backtest placed (modulo unavoidable real-world slippage). The agent’s output is fully auditable, fully reproducible, and fully separable from the math.

A backtest is not a robustness proof — see the robustness checklist for the full pre-deploy diligence. Frame the share URL as "the engine produces real numbers on a real strategy", not "this strategy is ready for live capital".

The five-step flow:

• 1. Compose. You describe a thesis in natural language to the agent. The agent searches the component library, picks the relevant signals + regime gates + sizing primitives, and authors a typed DSL graph. You review the graph (it is human-readable).
• 2. Backtest. The agent submits the strategy and calls the backtest engine. The engine runs deterministically against real Hyperliquid funding + price history. Results come back as a structured tearsheet — Sharpe, drawdown, hit rate, decomposed P&L by signal, exposure by asset.
• 3. Iterate. You ask the agent to adjust — different lookback, different gate threshold, different vol target. The agent forks the strategy, re-runs the backtest, and compares. This is the loop the LLM is genuinely good at.
• 4. Deploy. Once a candidate clears your pre-deploy checklist, you stage it for live execution. The compiled artifact moves to the execution layer. The agent is no longer in the path; the strategy runs on its own schedule.
• 5. Audit. Every live trade is recorded with a deterministic replay artifact. If something looks wrong, you (or the agent) can replay the exact bar through the engine and see the signal values, sizing decisions, and fill simulations side by side with the live fill.

Steps 1-3 are agent-driven. Steps 4-5 are deterministic. Both halves are doing what they are good at.

If a product page sells you any of the following, it is over-claiming what currently ships:

• "AI portfolio manager." No LLM should be making ongoing portfolio decisions on your funds without a deterministic strategy underneath. The "manager" is the compiled strategy, not the LLM.
• "Set-and-forget agent." Strategies need monitoring even when the LLM is not in the loop. Markets change. Regimes shift. A strategy that worked in backtest can degrade live. "Agent does it for you forever" is not a thing.
• "Vibe trading", "AI-powered alpha", "agent-managed wallet." Vocabulary that signals the autonomous-bot frame.

What Keel does ship: a deterministic backtest engine on Hyperliquid history with real fees, funding, and slippage, 182 typed DSL components, OAuth-secured MCP for agent-driven composition over MCP tools, bit-for-bit backtest-to-live parity, and non-custodial HL execution via native delegated signing. The verified backtest above is a real worked example.

If you want to try the strategy-builder frame yourself, the install is two commands:

pipx install keel-trade
claude mcp add keel -- keel mcp serve

First command installs the keel-trade CLI from PyPI; second registers the local-stdio MCP with Claude Code (Cursor / Windsurf / Codex have equivalent one-liners). First call triggers an OAuth login at app.usekeel.io. After that, the agent has access to all MCP tools — search components, compose strategies, run backtests, summarize results, fork, diff.

For the agent-specific landing pages on the keel-site (per-host setup, prompt patterns, the tutorial flow), see the Keel MCP product page and build a trading bot with Claude on Hyperliquid.