Kronos is a family of decoder-only foundation models for financial candlestick data. The README’s claim is specific: “the first open-source foundation model for financial candlesticks (K-lines), trained on data from over 45 global exchanges.” It is MIT licensed, with a paper — Kronos: A Foundation Model for the Language of Financial Markets (arXiv:2508.02739) — that the project notes was accepted by AAAI 2026.
The idea it borrows is the interesting part: treat OHLCV bars as a language. A tokenizer quantises multi-dimensional candlestick data into “hierarchical discrete tokens,” and a large autoregressive Transformer is pre-trained on those tokens. The model then predicts the next bars the way a language model predicts the next words.
The model zoo, with one catch
| Model | Context | Params | Open-source |
|---|---|---|---|
| Kronos-mini | 2048 | 4.1M | Yes |
| Kronos-small | 512 | 24.7M | Yes |
| Kronos-base | 512 | 102.3M | Yes |
| Kronos-large | 512 | 499.2M | No |
Three of four are released; the largest is not. Weights live on Hugging Face under NeoQuasar. Worth noting that Kronos-mini has the longest context at 2048 while small and base are capped at 512 — so the smallest model sees the most history, and the README advises keeping lookback within the max_context limit.
That inversion matters when choosing. If your signal depends on a long lookback, the 4.1M-parameter model may suit it better than the 102M one.
Running it
Python 3.10 or higher, then:
pip install -r requirements.txtfrom model import Kronos, KronosTokenizer, KronosPredictor
tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
predictor = KronosPredictor(model, tokenizer, max_context=512)
pred_df = predictor.predict(df=x_df, x_timestamp=x_timestamp,
y_timestamp=y_timestamp, pred_len=pred_len,
T=1.0, top_p=0.9, sample_count=1)The sampling parameters are a tell: T and top_p are language-model controls, applied here to price paths. A predict_batch method handles multiple series provided they share lookback and prediction lengths and each frame carries open, high, low and close.
Finetuning on daily Qlib data is documented and needs GPUs:
pip install pyqlib
python finetune/qlib_data_preprocess.py
torchrun --standalone --nproc_per_node=NUM_GPUS finetune/train_tokenizer.py
torchrun --standalone --nproc_per_node=NUM_GPUS finetune/train_predictor.pyWhat the authors say it is not
The README’s honesty here is the most useful thing for anyone weighing it, and it rules out the obvious misreading.
The finetuning pipeline is “a demonstration to illustrate the finetuning process” and “a simplified example and not a production-ready quantitative trading system.” The demo signals are “raw predictions” — the README states that a robust strategy needs further work such as portfolio optimisation and risk factor neutralisation to achieve stable alpha, and calls the included top-K strategy “a basic starting point.” On evaluation it is explicit that a realistic backtest must model transaction costs, slippage and market impact.
There is also an unusually candid note: some comments in finetune/ were AI-generated and “they may contain inaccuracies.” Flagging that is better practice than most repositories manage, and it tells you to read the code rather than the comments.
Where the value is
As research, it is a genuine contribution: a tokenizer design for multivariate price data, open weights at three sizes, and a paper to check the method against. If you want to study whether sequence modelling transfers to price series, you can do that here without training anything.
As a trading system, it is explicitly not one, and the gap the README describes — costs, slippage, market impact, risk neutralisation — is where most of the difficulty in quantitative finance actually lives. A model that predicts the next bars is the easy part.
Sensible first step: run Kronos-small against a series you know well, compare the forecast to the realised bars, and vary T to see how much the output moves. That will calibrate expectations faster than reading the paper.
