By Keel Research Team
Updated October 15, 2026AI-written trading bots usually blow up for reasons that have nothing to do with the idea behind them. The model writes the code, reports the results and often places the trades, so a mistake in any one of those jobs goes straight to your account. The safer setup splits the work: the AI helps you build and test a strategy, and a fixed engine does the maths and runs the trades.
People call the first version "vibe trading". You describe an edge to a chatbot, it writes a Python script, you look at a nice equity curve, fund a wallet and let it run. Each step looks reasonable. Put together, they skip most of the work that keeps a real strategy alive.
What the loop looks like
The usual sequence goes like this:
- Ask a model for a strategy: "buy SOL when funding flips negative, exit on a 3% drawdown".
- The model writes a script that downloads prices, computes the signal and sends orders.
- You run it on past data and look at the chart.
- If the chart looks good, you point the script at a live account.
The model is useful in steps 1 and 2. It reads API docs quickly, knows the indicators and writes boilerplate in seconds. A trader who used to need a week to set up a backtest can do it in an evening.
The trouble sits between steps 3 and 4. That gap holds most of what makes a strategy work or fail with real money: honest costs, a test on data the strategy never saw, sensible position sizes, and a live version that matches the one you tested.
Five ways it goes wrong
The numbers are made up
A language model predicts text. Ask it to compute a Sharpe ratio or a drawdown from a list of returns and it will usually get close. Sometimes it returns a figure with the right size and the right shape that is simply wrong. In an essay that is a typo. In a trading system it decides how much money goes into a position.
If the same model also wrote the sizing code, one bad number feeds the next decision. Asking more carefully doesn't fix this. The fix is to keep the model away from the numbers: it should call an engine that computes them, and report what the engine returned.
Nothing was tested out of sample
A generated backtest rarely holds data back. Even when it does, the model saw the dates, the coin and the result you were hoping for in your prompt. And most people try many variants before one looks good. The best of twenty tries on the same data looks better than it is, because you picked the luckiest one.
You have to choose to measure that. Keep a period the strategy never saw, count how many versions you tried, and expect the live result to be worse than the best backtest. The model will not do this for you unless you ask, and it can't do it reliably even when you do.
Funding is missing
Perpetual futures charge or pay funding while a position is open. On Hyperliquid that happens every hour. For a strategy that holds for more than a few hours, funding can be a large part of the profit or loss.
Many generated backtests leave funding out, or plug in one average rate. A strategy that collects funding then looks like a great trading signal, and a strategy that pays it looks worse than it is. Both readings are wrong.
Sizing by feel
Volatility targeting, risk limits per coin and caps on total exposure are solved problems. A model asked to "write the bot" usually picks a fixed fraction instead, such as 20% of the wallet on every signal, with no attention to how volatile the coin is or how much is already open. The backtest looks fine because the test period was calm. The first sharp move takes more than the backtest said you could lose.
The live bot is not the bot you tested
Even with an honest backtest, the script that trades live is often a different program. The backtest assumed perfect fills; the exchange gives you slippage. The backtest used one fee tier; your account pays another. The order types differ. The live strategy is a cousin of the tested one, and the difference shows up as a slow leak nobody can explain.
A safer way to use AI
Give each job to the tool that is good at it. The AI turns your idea into a strategy, explains results and suggests changes. A fixed engine runs the backtest, computes every number, charges fees, slippage and funding, and places live orders. The AI never sits in the trading loop.
| Script written by a chatbot | Strategy built with AI, run by an engine |
|---|---|
| The model writes code you run | The model assembles a strategy from known building blocks |
| Metrics come from the model | Metrics come from the backtest engine |
| Funding left out or averaged | Real Hyperliquid funding applied to every open position |
| Live code differs from tested code | The same compiled strategy runs in the backtest and live |
| The model can place trades | The strategy places trades on its own schedule |
This is how Keel works. You describe the idea in plain words, in the Keel app or from an assistant such as Claude or ChatGPT. The AI builds the strategy from Keel's building blocks, each with known inputs, outputs and settings, and Keel checks that they fit together before anything runs. It can't invent an indicator that doesn't exist.
The backtest charges trading fees and slippage on every trade and applies Hyperliquid's real funding payments to every open position. Then you can paper trade the same strategy on live prices with no money at risk. When you go live, Keel runs the same compiled strategy you tested. Your money stays in your own Hyperliquid account: Keel can place trades there but can never withdraw.
If you want to see a finished example, every strategy in the strategy library shows its full backtest, costs included, and you can start from one and change it.
What Keel does not do
A backtest over one period is still one period. Keel runs your strategy over the dates you choose and keeps every run, so you can compare versions. It does not run walk-forward optimization, Monte Carlo resampling or overfitting scores for you; those are not in the product, and Keel is not a research stack. What it does is keep the language model away from the maths and the trades while you build, test and run a strategy.
Paper trading is the cheap check in between. A strategy that falls apart on live prices for a few weeks has told you something no backtest could.
Before you fund a bot
Whatever tool you use, ask these questions first:
- Who computed the numbers: the model, or an engine you can check?
- Was any data held back, and how many versions did you try?
- Does the backtest charge fees, slippage and funding?
- Is the live code the same code you tested?
- Can the bot withdraw your money?
If a chatbot hands you a strategy and a Sharpe ratio in the same message, ask which one of them actually ran the backtest.
Try it: build a strategy with AI, or connect your assistant through the agents page.