# Kronos (slim)

> Kronos is an open-weight family of small forecasting models for financial candlestick (K-line) series, from Tsinghua University researchers. It reads open, high, low, close, volume and amount bars with timestamps and generates forecast bars, under MIT.

- Full: https://www.anchorterminal.com/tools/kronos.md (~8,650 tokens) · this version ~2,280 tokens · JSON https://www.anchorterminal.com/tools/kronos.json · canonical https://www.anchorterminal.com/tools/kronos
- Index: https://www.anchorterminal.com/llms.txt · API: https://www.anchorterminal.com/api/v1/index.json · MCP: https://www.anchorterminal.com/mcp · Updated: 2026-10-25 · pricing https://www.anchorterminal.com/tools/kronos#pricing · reviews https://www.anchorterminal.com/tools/kronos#reviews
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)

**C · 55.2/100 · rank #86 of 110 open-weight models · #68 in Open-weight models · not agent-ready · confidence low**


Assessment: Forecasts the next price bars from a history of up to 512 candlestick bars. Every size fits in under 0.5 GB and runs on a CPU, but only through the publisher's own Python package. Nobody has benchmarked it independently, its quickstart data was deleted from the repository, and the publisher hasn't replied since November 2025.

## Facts

- Kind: Open-weight model · vendor: Yu Shi (shiyu-coder, NeoQuasar), Tsinghua University · category: Open-weight models · legal entity: No company. Yu Shi publishes it from the GitHub account shiyu-coder and the Hugging Face user account NeoQuasar (named ShiYu), with co-authors at Tsinghua University per the paper · provenance 40/100
- Packages: huggingface `NeoQuasar/Kronos-mini`, huggingface `NeoQuasar/Kronos-small`, huggingface `NeoQuasar/Kronos-base`, huggingface `NeoQuasar/Kronos-Tokenizer-base`, huggingface `NeoQuasar/Kronos-Tokenizer-2k`
- Auth: None · pricing: Free · x402: no · licence: MIT
- Probe metrics: not measured yet (probes haven't run)
- Surface graded: The open weights in the five NeoQuasar repositories on Hugging Face (Kronos-mini, Kronos-small, Kronos-base and the two tokenisers), read from the cards, the files and their metadata, the publisher's GitHub repository (cloned into scratch), the paper and the runtimes' own pages on 25 October 2026. Nothing was downloaded or run. Nobody hosts an API for it
- Model: Two stages. A tokeniser (3.96M parameters, a Transformer encoder and decoder) quantises each bar of open, high, low, close, volume and amount into a hierarchical pair of 10-bit subtokens, and a decoder-only Transformer predicts the next pair autoregressively, with learned embeddings for minute, hour, weekday, day and month. Kronos-mini 4,108,192 parameters (4 layers, d_model 256), Kronos-small 24,741,696 (8 layers, 512), Kronos-base 102,311,008 (12 layers, 832), all FP32, counted from the files. Trained from scratch, not a language model
- Files: One model.safetensors and a config.json in each repository, with no pickle files and no Python. Kronos-mini 16.4 MB, Kronos-small 99.0 MB, Kronos-base 409.3 MB, Kronos-Tokenizer-base 15.8 MB, Kronos-Tokenizer-2k 15.8 MB. Hugging Face lists a SHA-256 for every weight file. The model code (model/kronos.py and model/module.py) is only in the GitHub repository and loads the files with huggingface_hub's PyTorchModelHubMixin
- Licence: MIT in each card's metadata and License section, and MIT in the GitHub repository's LICENSE (copyright 2025 ShiYu). No LICENSE file in the Hugging Face repositories. No use policy. The cards link the licence at blob/main/LICENSE, but the repository's only branch is master, and raw.githubusercontent.com answers 404 for main and 200 for master
- Runtimes: Only the publisher's own PyTorch code, cloned from GitHub, with torch 2.0 or later, huggingface_hub 0.33.1, safetensors, einops, pandas and numpy. Not in Transformers, vLLM, SGLang, llama.cpp, Ollama or LM Studio. Runs on CUDA, Apple MPS or CPU (the predictor picks one, and the regression test runs on CPU)
- Input and output: predict takes a pandas DataFrame with open, high, low and close (volume and amount optional, filled with zeros if missing), the timestamps of those rows, the timestamps to forecast and pred_len. It returns a DataFrame of the six fields indexed by the requested timestamps. sample_count draws several paths and returns their mean, not the paths. predict_batch runs several series of equal length in parallel. Inputs are normalised per series and clipped at 5 standard deviations
- Context: 512 bars for Kronos-small and Kronos-base and 2,048 for Kronos-mini, per the cards. The predictor's max_context defaults to 512 and truncates longer histories. The paper says the context was limited to 512 tokens
- Recommended settings: T 1.0, top_p 0.9 and sample_count 1 in the card's example, a lookback of 400 bars and no more than max_context. Pair Kronos-mini with Kronos-Tokenizer-2k and the other two with Kronos-Tokenizer-base
- Hardware: No inference memory is stated. The paper trained and evaluated on 24 NVIDIA GeForce RTX 4090D GPUs. The largest public build with its tokeniser is 0.43 GB of FP32 files
- Training data: Over 12 billion K-line records from 45 exchanges at seven frequencies from 1-minute to weekly, per the paper's abstract. Its appendix lists each exchange or index market with asset types, timeframes, asset and observation counts and start dates (mostly January 2020), describes the cleaning and filtering pipeline with its thresholds, and says crypto, futures and forex were up-weighted. The pre-training data extends to June 2024. The data itself isn't published and the vendor it came from isn't named. The appendix's text says over 40 exchanges in more than 30 countries

- Scores: Capability pending, Reach 55, Risk 50, Agent interface 60, Documentation and upkeep 61 · total over the 7 assessed categories
- Why:  · Reach, Memory 30, the publisher's Kronos-mini with its tokeniser is 0.03 GB and even Kronos-base is 0.43 GB in FP32. Runtimes 0, it runs only throu… · Risk, File safety 15, safetensors only, but the only documented loading path is the publisher's Python package in place of a runtime. · Agent interface, Read for a forecasting model, the tool-calling, trained tool calling and structured-output lines stand for what it takes and returns. · Documentation and upkeep, Model card 11, intended use, architecture, parameters and context are there, limitations, languages and a cut-off aren't.
- Sources: 16, open questions: 6, both in the full twin
- Capabilities: model.open-weights
- JSON: https://www.anchorterminal.com/api/v1/tools/kronos.json
- Verify (for the vendor): the badge `https://www.anchorterminal.com/badges/kronos.svg` or a link to https://www.anchorterminal.com/tools/kronos from a page under github.com/shiyu-coder, or the README of github.com/shiyu-coder/Kronos, then `POST https://www.anchorterminal.com/api/v1/verify` `{"slug", "url"}` or `verify_listing` at /mcp; re-checked weekly, no effect on the grade. Snippets in the full twin.

## Before you call it

1. Clone https://github.com/shiyu-coder/Kronos and `pip install -r requirements.txt`, then load `Kronos.from_pretrained("NeoQuasar/Kronos-small")` and `KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")` and wrap them in KronosPredictor
2. Pair Kronos-mini with Kronos-Tokenizer-2k and Kronos-small or Kronos-base with Kronos-Tokenizer-base, the cards' pairing
3. The examples read examples/data/XSHG_5min_600977.csv, which no longer exists; point them at tests/data/regression_input.csv, 2,500 five-minute bars
4. Keep the lookback at or under max_context, 512 bars, and pass the future timestamps you want as y_timestamp, since the calendar fields come from them
5. Raise sample_count for a steadier forecast, but expect only the mean back; call the lower-level auto_regressive_inference yourself if you need the paths
6. Treat forecasts as model output to check, not signals; the README says its own backtest pipeline isn't a production trading system

## Connect

```bash
git clone https://github.com/shiyu-coder/Kronos && cd Kronos
pip install -r requirements.txt   # Python 3.10+, PyTorch 2.0+
python - <<'EOF'
import pandas as pd
from model import Kronos, KronosTokenizer, KronosPredictor
tok = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
p = KronosPredictor(model, tok, max_context=512)   # picks cuda, mps or cpu
df = pd.read_csv("tests/data/regression_input.csv", parse_dates=["timestamps"])
x, y = df.iloc[:400], df["timestamps"].iloc[400:520]
cols = ["open", "high", "low", "close", "volume", "amount"]
print(p.predict(df=x[cols], x_timestamp=x["timestamps"], y_timestamp=y, pred_len=120, T=1.0, top_p=0.9, sample_count=1).head())
EOF
```

## Similar tools

| Tool | Grade | Score | Shared capabilities | Slim |
| --- | --- | --- | --- | --- |
| Qwen3-Embedding-8B | BB | 74.7 | model.open-weights | https://www.anchorterminal.com/tools/qwen3-embedding-8b.min.md |
| Gemma 4 31B IT | BB | 74.1 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-31b-it.min.md |
| Qwen3-Embedding-4B | BB | 72.9 | model.open-weights | https://www.anchorterminal.com/tools/qwen3-embedding-4b.min.md |
| Gemma 4 26B A4B IT | BB | 72.2 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-26b-a4b-it.min.md |
| Gemma 4 12B IT | BB | 71.3 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-12b-it.min.md |


## Panel reviews (0, desk reviews from public material, no calls made)