Agentic trading is trading in which an AI agent, such as Claude or ChatGPT, uses tools to research markets, build strategies or place orders in an account on your behalf. You set the limits: which account it can reach, what it may do there, and what needs your approval.
The term covers two different products. In one, an AI agent is connected to a brokerage or exchange account and sends orders. Robinhood, Coinbase, Public and others offer this today, and the comparison below lists eleven of them. In the other, the agent writes a strategy once, and a fixed engine tests it and runs it. The risks are very different, so it is worth knowing which one a product means.
This page explains how agentic trading works, compares the platforms from their own pages, and shows where language models help in trading and where they fail. For the protocol most of these products use, see what is MCP.
Every agentic trading setup has the same four parts. What differs between products is how much each part is allowed to do.
When you compare products, read the tools and the guardrail first. They decide what a wrong answer from the model can cost.
Eleven platforms that let an AI agent work in a trading account, in no ranked order. Each row states what the platform’s own page said when we read it on , and links that page. Coinbase’s page blocks automated readers, so its row cites the TechCrunch report of its launch. A cell reads “Not stated” when the source does not say. These products change quickly, so check the source before you rely on a row.
| Platform | What the agent can do | The guardrail | Markets | Launched |
|---|---|---|---|---|
| Robinhood Agentic Trading Source: robinhood.com, read | Connect your own AI agent over MCP to a dedicated Robinhood account. The agent can scan the market, review the portfolio, build watchlists and place trades. | A separate account you fund for the agent. You review each trade before it is placed, and approvals are on by default. | Not listed on the page | Not stated. Agent Loops, for continuous or scheduled runs, is listed as coming. |
| Coinbase for Agents Source: techcrunch.com, read | An agent that places trades and pays for research, which also works from ChatGPT or Claude through Coinbase's MCP server. | The agent can run in a separate sandbox. Custom limits such as a maximum trade size were described as coming. | Crypto spot and derivatives | June 11, 2026 |
| Alpaca MCP Server Source: alpaca.markets, read | Pull live or historical market data and place orders in plain language from clients such as Claude, ChatGPT and Cursor. | Paper trading with simulated funds. Going live is a change of API keys. The page says you see every prompt, parameter and order payload before anything goes to market. | US stocks, ETFs, options and crypto | Not stated |
| Public Source: public.com/mcp-trading, public.com/ai-agents, read | Connect Claude, ChatGPT or Perplexity over MCP to read the portfolio and place trades. In-app Agents monitor markets, place trades and manage cash on rules you set. | Dedicated brokerage accounts for MCP connections. Inside one, the agent can trade without your input on each transaction. Each in-app Agent needs your sign-off before it runs. | Stocks, ETFs, options, crypto and bonds over MCP. Stocks, options and crypto for in-app Agents. | Not stated |
| Interactive Brokers Source: interactivebrokers.co.uk, read | Connect ChatGPT, Claude, Grok, Perplexity and other MCP clients for research, portfolio analysis and preparing trade instructions. IBKR Autonomous Trading lets eligible clients authorize an AI to place supported trades on criteria they set. | By default you review and submit every order yourself. Autonomous Trading runs only inside a dedicated AI Partition, which limits the cash, products and trading authority the AI gets. | Autonomous Trading covers eligible stocks and equity options | Not stated |
| Kraken CLI Source: docs.kraken.com, read | A command-line tool with a built-in MCP server that gives an agent Kraken's trading and account commands. | A paper trading engine that runs on live prices. Login saves a restricted API key with no withdrawal rights and an expiry date. | Crypto spot, tokenized stocks, forex, and perpetual and dated futures | Not stated |
| OKX Agent Trade Kit Source: okx.com, read | An open-source MCP server and command-line tool for Claude, Cursor, VS Code and other MCP clients: market data, orders, and grid and DCA bots. | A demo mode with simulated assets. If the API key has no trading permission, the order tools are never given to the agent. | Spot, perpetual swaps, futures and options | March 10, 2026 |
| Binance Skills Hub Source: binance.com, read | “An open skills marketplace giving AI agents native access to crypto”: skills for exchange trading, on-chain swaps, wallet operations and market data. | Skills are security-reviewed before listing, and the trading skill requires authentication. | Binance spot, futures and Convert, plus on-chain swaps | Not stated |
| Gemini Agentic Trading Source: gemini.com, read | The full Gemini trading API over MCP, so Claude, ChatGPT or another AI can place trades, monitor markets and manage risk. | Not described in the announcement | Crypto. The announcement lists no specific markets. | April 27, 2026 |
| TradeStation Institutional Source: tradestation.com, read | Connect Claude, ChatGPT and other assistants to a brokerage account over MCP to pull historical data, run analysis and build multi-leg orders in conversation. | “No trade executes without your explicit approval.” | Equities, options and futures | Not stated |
| tastytrade MCP server Source: developer.tastytrade.com, read | An open-source MCP server you host yourself: market data, account data, and placing, replacing and cancelling orders. | An order needs a dry run first, then a single-use confirmation token that lasts 60 seconds. A sandbox environment holds no real money. | Options are covered in detail. The page gives no full list. | Not stated |
Read down the guardrail column and one pattern repeats. Each of these products gives an agent an account and a way to send an order, then limits the damage in one of three ways: a separate account that holds only what you assign, an approval before each order, or a cap on what the agent may trade. The model still decides each trade in the moment. The guardrail limits what a wrong decision can cost. It does not let you test the decision before it is made.
Keel is not in the table because it gives the agent no order to send. That design is the next section. For connectors that bring charts and market data to an agent, see MCP servers for trading, and for projects you run yourself, see open-source AI trading agents.
There is a second way to use an agent, and it needs no guardrail on orders because the agent never sends one. The agent writes a strategy once: which coins, what signal, how big each position is, how often to rebalance. A fixed engine then tests that strategy over past data. If you start it, the engine runs it as written, the same way every time, with no model in the loop.
This is what Keel does. Keel is a strategy builder for Hyperliquid. Through Keel’s Hyperliquid MCP an agent such as Claude or ChatGPT can search the building blocks, write a strategy, backtest it on Hyperliquid data and compare versions, all in one conversation. It has no tool that sends orders. When a strategy is ready, the agent gives you a link to it in the Keel app, and you start it there yourself.
| The agent places orders | The agent writes the strategy | |
|---|---|---|
| Who decides each trade | The model, in the moment | Rules you approved, on a schedule |
| Can you test it first | Rarely. Its choices depend on the prompt and the day | Yes. The same rules run over past data with fees, slippage and funding |
| What you can read | Its explanation after the fact | Every block and setting, before it runs |
| What limits a mistake | A separate account, an approval or a cap | The agent has no order to send. You start the strategy yourself |
The second design has its own limit. The agent can still propose a bad strategy, and a backtest cannot prove a good one. What changes is where the mistake shows up: in a result you read before any money moves, not in a position.
Language models are sharp at work that has many valid answers: prose, putting code together, refactoring, summarizing, explaining what something does. They make things up on work that has one correct answer: arithmetic, exact state, accounting. Trading has both kinds. Composing a thesis (which signals to combine, what regime to gate on, what volatility to target) is the soft side. There are many reasonable answers, and a good model iterates quickly. Computing P&L is the hard side. There is exactly one correct answer, and a model that invents a fill price is breaking your execution.
That split explains the failures you see when a model sits in the trading loop:
The builder design lines up with the split: soft work to the model, exact work to the engine. To see what happens when models trade for themselves in public, read the recap of the Alpha Arena AI trading contest. For how the models differ from each other, see LLM trading with Gemini, Grok and DeepSeek.
An AI trading agent is a model such as Claude or ChatGPT that can use tools: search for components, run a backtest, read the result. In agentic trading on Keel, you connect your agent to Keel and ask it for a strategy in plain words. It builds the strategy from Keel’s blocks, so every rule is one you can read, and Keel runs the backtest on real Hyperliquid data with fees, slippage and funding charged.
Keel works with Claude, ChatGPT and other MCP clients. The setup and a prompt to start from are on the page about an AI agent for trading on Hyperliquid.
A user asks an MCP client (Claude Code, Cursor or Codex, any of them) to build a funding-carry strategy with a funding-level regime gate and backtest it. The agent searches the component library, finds the carry signal and the regime component, composes the strategy, submits it with keel_strategy_compose and starts keel_backtest_run.
The engine runs it on Hyperliquid perps with fees, slippage and funding charged, and returns the Sharpe, return and drawdown. For a run anyone can open, see funding carry in the strategy library, whose page shows its published backtest.
The point: the agent did not compute the Sharpe. The agent composed the strategy, and the engine computed the result from the saved strategy. Run the same strategy again and you get the same result. The agent’s work can be read, repeated and separated from the math.
A backtest shows how the rules behaved in the past. It is not proof that a strategy is ready for live capital. See the robustness checklist for what to check before you deploy, and trading prompts that end in a backtest for prompts to start from.
Some pitches claim more than any of the designs above delivers:
What Keel ships: a backtest engine on Hyperliquid history with fees, slippage and funding, typed building blocks that an agent composes over MCP, and trading from your own Hyperliquid account through an agent wallet that can place trades but can never withdraw.
To try the builder design yourself, the install for Claude Code is two commands:
pipx install keel-trade
claude mcp add keel -- keel mcp serveThe first command installs the keel-trade command-line tool from PyPI. The second registers it with Claude Code. The first call opens a sign-in at app.usekeel.io. After that, the agent can search components, compose strategies, run backtests, summarize results, and copy and compare versions.
For setup in other clients and prompts to start from, see the Keel MCP product page, ChatGPT for trading and build a trading bot with Claude on Hyperliquid.
Keel is a strategy builder for Hyperliquid. Describe an idea, backtest it with fees, slippage and funding, and run it live on Hyperliquid’s crypto perps. Stock and index perps are coming soon.
Start free. Connect a Hyperliquid wallet when you’re ready to trade.
Agentic trading is trading in which an AI agent uses tools to do part of the work for you: research, building a strategy, or placing orders in an account. The term covers two designs. In one, the agent is connected to a brokerage or exchange account and sends orders, usually inside a guardrail such as a separate account or an approval step. In the other, the agent writes a strategy once and a fixed engine tests it and runs it, so no model decides a trade in the moment. Keel is built the second way.
An AI model, such as Claude or ChatGPT, that can use tools to do work for you rather than only answer questions. For trading, the useful work is building a strategy, running a backtest and explaining the result. On Keel the agent does that design work, and the tested strategy is what trades, at the close of each bar, from your own Hyperliquid account.
It depends on what the agent is allowed to do. An agent that can send orders turns a wrong answer into a real position, which is why the platforms that allow it add a guardrail: a separate account funded with only what you assign, an approval before each order, or a cap on what it can trade. A guardrail limits the size of a mistake. It does not stop one. With Keel the agent has no tool that sends orders and cannot withdraw funds, and the strategy it wrote is backtested before you decide to run it. A backtest shows how rules behaved in the past and is not a guarantee, so any strategy can still lose money.
There is no single best one, because the agent is only half of the setup. Claude, ChatGPT and similar assistants are general agents, and what they can do in a market depends on the tools you connect them to. Compare platforms on three things: what the agent can do, what guardrail limits it, and which markets it reaches. The table on this page lists those for eleven platforms, each with its source. If you want an agent to build a strategy and test it before anything trades, that is what Keel is for.
Yes. Coinbase, Kraken, OKX, Binance and Gemini each offer a way to connect an AI agent to a crypto account, and Alpaca and Public include crypto beside stocks. On Keel an agent builds and backtests strategies for Hyperliquid's crypto perpetuals. The strategy you approve then trades from your own Hyperliquid account on a fixed schedule, and the agent places no orders.
A trading bot runs fixed rules that someone wrote in advance, and it does the same thing every time. In agentic trading a model chooses what to do through tools, so it can research, adapt and explain, and it can also be wrong in ways fixed rules are not. The two meet when an agent writes the rules: the agent does the building, and what runs afterward behaves like a bot you can read and backtest.
No. Once a strategy is built and started, it runs on Keel on its own schedule. The agent does not need to be open, connected or installed. A model in the trading loop adds delay, cost and a chance of a made-up answer on every decision, so Keel keeps the model out of that loop.
Two commands. pipx install keel-trade installs the Keel command-line tool from PyPI, and claude mcp add keel -- keel mcp serve registers it with Claude Code. The first call opens a sign-in at app.usekeel.io. After that the agent can search components, build strategies, run backtests and summarize results. Setup for other clients is at usekeel.io/docs/getting-started.
The Model Context Protocol: the open standard that lets agents like Claude call typed external tools.
From an idea to a validated backtest: the workflow that keeps the engine in charge.
The pre-deploy checklist any strategy, agent-composed or not, should clear before live capital.
What a realistic backtest looks like: fees, slippage and funding, shown on one public strategy.