Short answer: AI cannot reliably predict stock prices, at least not short-term price moves. I ran Kronos, an open source AI model trained only on market charts, on 30 real Bitcoin forecasts. Its 24-hour guesses missed by about 2.7% to 3.2% on average. Simply guessing “the price stays the same” missed by about 1%.
You have probably seen the screenshot. A smooth orange line drawn over a price chart, landing almost exactly where the real price went. The caption says AI can now read the market.
That picture is the thread of this post. A single good-looking forecast proves almost nothing, and below you will see why, with a test you can run yourself in about 10 minutes on a normal laptop.
What does “predicting a price” actually mean?
Before judging any AI, you need to know what it is being asked to guess. Traders look at prices as candles (small bars that pack one time slice of trading into four prices).
Each candle stores the open (first price in that slice), the high, the low, and the close (last price). Most charts also add volume (how much was traded). String hundreds of candles together and you get the chart you see on any trading app.
So “predict the price” means one concrete thing here. Show the AI the last 400 hourly candles, and ask it to draw the next 24.
What is Kronos and how does it work?
Kronos is a free, open source AI model built to read and continue candle charts, the same way a chatbot continues text. To see why that idea is clever, start with how a chatbot works.
A chatbot does not understand a whole sentence at once. It breaks text into tokens (small chunks, roughly word pieces), then guesses the most likely next token, again and again. That guessing engine is called a transformer (the neural network design behind most modern AI).
Kronos copies that recipe for markets. A tokenizer (a converter that turns raw data into a short list of code numbers) squeezes each candle into two codes, one rough and one fine. The transformer then guesses the next code, one candle at a time, and a decoder turns the codes back into prices.
The team calls it a foundation model (one big model pre-trained on lots of data so it works on new data without extra training). Their paper says it learned from over 12 billion candles across 45 exchanges. You can download three sizes for free: mini, small and base. The largest version has not been released.
Why “the price stays the same” is the test that matters
Any forecast is only useful if it beats the dumbest possible guess. In forecasting, that dumb guess is called a naive baseline (a guess so simple it needs no skill at all).
For prices, the classic naive baseline is “the next price equals the last price.” It sounds silly. It is famously hard to beat, because short-term price moves behave close to a random walk (each next step is roughly a coin flip around where you are now).
Think of a weather forecaster who says “tomorrow will be like today.” That forecaster is right surprisingly often. A fancy model that cannot beat that line is adding noise, not skill.
This is the check most AI trading demos skip. Keep it in mind for every chart below.
Can an open source AI model predict Bitcoin prices? My test
I gave Kronos 30 chances to forecast Bitcoin a day ahead, and it lost to the do-nothing guess on most of them. Here is the setup.
- I pulled about 100 days of real hourly Bitcoin candles from a public exchange feed.
- I picked 30 starting points spread evenly across that stretch.
- At each point, Kronos saw the previous 400 hours and forecast the next 24.
- I compared its final forecast with the real price 24 hours later, and with “no change.”
I ran three versions: Kronos-small, Kronos-small averaging 5 forecast paths (it samples a little randomly, so averaging smooths it), and the larger Kronos-base. Everything ran on a plain 2-core computer with no graphics card.
The results, averaged over all 30 forecasts:
| Forecaster | Average miss after 24 hours | Got the direction right | Beat “no change” |
|---|---|---|---|
| Kronos-small | 3.18% | 50% | 9 of 30 |
| Kronos-small, 5 paths averaged | 2.74% | 43% | 7 of 30 |
| Kronos-base | 2.67% | 43% | 9 of 30 |
| “Price stays the same” | 1.01% | n/a | n/a |
Read the direction column first. Up or down is a two-way choice, so 50% is exactly a coin flip, and 43% is slightly worse than one.
Then the miss. Every Kronos version missed by roughly two and a half to three times more than doing nothing. The bigger model and the averaging helped a little, but not enough to close the gap.
Why did the forecasts go so wrong?
The worst misses came right after a fast rally. Kronos pulled its forecast back toward the old price. In three windows in a row, Bitcoin had just jumped from around 64,000 to around 77,000 dollars in a few days.
Kronos forecast a slide back toward 64,000. The real price stayed near the top. For Kronos-small, those three forecasts missed by 11% to 17%.
One reason shows up in the code. Before forecasting, Kronos rescales every price against the average of the window it was shown. After a rally, most of that window sits far below the current price, and in my test the forecast drifted back toward that old average.
That is a fair thing to check, so I removed those three windows and recounted. Kronos-small still missed by 1.89% on average, against 0.81% for “no change.” The gap shrank, but the order did not flip.
So is the demo chart a lie?
No, it is just one window. Cherry-picking (showing only the examples that look good) makes almost any model look smart. On calm stretches, Kronos draws a shape that looks very convincing.
In the chart above, it caught the rise and the flat top well. If that were the only chart you saw, you would believe the screenshot. The 30-window table is what tells you the truth.
To be fair to the model, the paper does not claim it nails single prices. Its headline number is a 93% better RankIC (a score for how well a model ranks many stocks against each other) than the leading general-purpose forecasting model. Ranking which of 300 stocks will do best is a different job from guessing one coin’s exact price tomorrow, and my test did not measure it.
The paper also reports better volatility forecasts (predicting how wildly a price will swing, not which way). That could be useful for sizing risk. It is still a claim I have not tested.
How do you test any AI stock prediction model yourself?
Never trust a forecast chart until it beats “no change” across many windows you picked in advance. That one rule filters out most AI trading hype, whatever the tool.
Use this checklist on any model, paid or free:
- Walk-forward test (forecast only from data the model could have seen at that moment, then step forward).
- At least 30 windows, chosen evenly, never hand-picked.
- Compare against “price stays the same” every time.
- Check direction hit rate. Near 50% means no edge.
- Look hardest at the worst windows. That is where real money is lost.
- Add trading fees before believing any profit number.
Here is the script I used, trimmed. Get the code from the Kronos repo and read the paper if you want the full method. It needs Python, the Kronos code, and these packages: torch, pandas, einops, huggingface_hub, safetensors.
git clone https://github.com/shiyu-coder/Kronos
pip install torch pandas einops huggingface_hub safetensorsimport json, time, urllib.request, sys
import numpy as np, pandas as pd
sys.path.insert(0, "Kronos")
from model import Kronos, KronosTokenizer, KronosPredictor
# 1. About 100 days of hourly BTC candles (public feed, no key)
end, rows = int(time.time()), []
for s in range(end - 100*86400, end, 40*86400):
url = ("https://api.india.delta.exchange/v2/history/candles"
f"?resolution=1h&symbol=BTCUSD&start={s}&end={min(s+40*86400, end)}")
rows += json.load(urllib.request.urlopen(url))["result"]
df = pd.DataFrame(rows).drop_duplicates("time").sort_values("time").reset_index(drop=True)
df["ts"] = pd.to_datetime(df["time"], unit="s")
# 2. Load the model (downloads once, runs on CPU)
tok = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
pred = KronosPredictor(model, tok, device="cpu", max_context=512)
# 3. 30 walk-forward windows: 400 hours in, 24 hours out
LOOK, H, cols = 400, 24, ["open", "high", "low", "close", "volume"]
ai_err, naive_err = [], []
for s in np.linspace(0, len(df) - LOOK - H - 1, 30).astype(int):
x, y = df.loc[s:s+LOOK-1], df.loc[s+LOOK:s+LOOK+H-1]
p = pred.predict(df=x[cols].reset_index(drop=True),
x_timestamp=x.ts.reset_index(drop=True),
y_timestamp=y.ts.reset_index(drop=True),
pred_len=H, verbose=False)
last, real = x.close.iloc[-1], y.close.iloc[-1]
ai_err.append(abs(p.close.iloc[-1] - real) / last * 100)
naive_err.append(abs(last - real) / last * 100)
print(f"Kronos miss {np.mean(ai_err):.2f}% vs no-change miss {np.mean(naive_err):.2f}%")On a 2-core machine, each Kronos-small forecast took under 3 seconds and each Kronos-base forecast about 9. Your exact numbers will differ, because prices and random sampling differ.
One warning from my own runs. When I first tried only 3 windows to check the script worked, Kronos won: 0.70% miss against 1.05% for no change. Over 30 windows, it lost badly. Small tests lie, so always run the full 30.
Is Kronos worth using at all?
Yes, as a research toy and a learning tool. No, as a signal you trade on as-is. It is free, small enough for a laptop (unlike the tricks needed to run a 70B model on a 4GB GPU), and the code is short enough to read in an evening.
It is also a great way to learn how foundation models work outside of text. The same tokenize, guess, decode loop powers chatbots, music models and now chart models (for the text side, here is what is actually in DeepSeek’s open inference engine).
The honest catch: the team’s own notes say their backtest example is a demo, not a production trading system. Fine-tuning (retraining the model a bit on your own market’s data) is supported, and that may change results for a narrow market. Test it the same way before you believe it.
That orange line from the screenshot is still worth a look. Just ask one question before you trust it: did it beat “no change” thirty times in a row, or only once?
Common questions about AI stock prediction
Can AI predict the stock market accurately?
Not for short-term price moves in this test. Kronos missed by 2.7% to 3.2% a day ahead on Bitcoin, while guessing “no change” missed by about 1%.
Is Kronos free and open source?
Yes. The code is MIT licensed, and the mini, small and base models are free to download. The largest model is not released.
Can I run Kronos without a GPU?
Yes. Kronos-small and Kronos-base both ran on a 2-core CPU with no graphics card, taking a few seconds per 24-hour forecast.
What is the best way to check an AI trading model?
Test it on at least 30 windows and compare it with “price stays the same.” No win means no edge.
