Mistral releases Timestral: time-series models from 5M to 209M parameters

Mistral AI has unveiled Timestral, a family of small foundation models for time-series forecasting. They predict trends such as sales or sensor data with no extra training, and according to the company they lead on three benchmarks.

Model releases Try it yourself Oct 14, 2026 4 min read Source: Hugging Face Trending

What it's about

Mistral AI has released the Timestral model family on Hugging Face. These are foundation models (large, pretrained general-purpose models) for time-series forecasting. A time series is a sequence of measurements over time, such as power consumption, sales figures or temperatures. Timestral is meant to forecast such trends "zero-shot", meaning you don't have to train the model on your own data first. The family includes versions with 5, 28, 123 and 209 million parameters (parameters are, roughly speaking, the dials a model learns during training). This entry covers the largest checkpoint, Timestral-209M. The weights are available for download, and the source code is on GitHub.

What the model can do

Timestral supports univariate forecasts (one series) and multivariate forecasts (several related series). You can also include covariates, meaning extra information. These can be variables known only from the past, or ones that are also known for the future, such as holidays or planned price promotions. They can be numeric or categorical; categorical values are converted via target encoding. Missing values are marked as NaN.

The forecasts are probabilistic: the model outputs 21 quantiles (0.01, 0.05, 0.1, 0.15 through 0.85, 0.9, 0.95, 0.99). Besides the median, you get uncertainty bands, for example the 10% and 90% quantiles.

Architecture

According to the Model Card, Timestral-209M is a patch-based transformer with 24 layers and an embedding dimension of 768. A patch groups 32 time steps and is embedded together with indicators for missing values. The model uses two kinds of attention: time attention (across time) and variate attention (between different variables).

Context: up to 32,768 time steps (1,024 patches)
Horizon: up to 1,024 steps (32 patches) in one forward pass
Longer horizons: block-wise forecasting, where the median forecast of each block is appended to the context
Inference: PyTorch on CPU or GPU

Benchmarks

Mistral says Timestral-209M achieves the best zero-shot result on three benchmarks: GIFT-Eval, TIME and fev-bench. For MASE and CRPS, lower is better; for the skill scores, higher is better. MASE measures error relative to a simple baseline forecast, and CRPS measures the quality of the probabilistic forecast.

Benchmark	Metric	Timestral-209M	t0-gamma	TimesFM-3	Toto-2.0-2.5B	Chronos-2
GIFT-Eval	MASE ↓	0.658	0.661	0.667	0.696	0.698
GIFT-Eval	CRPS ↓	0.446	0.452	0.456	0.476	0.485
TIME	MASE ↓	0.626	0.637	0.640	0.642	0.662
TIME	CRPS ↓	0.522	0.534	0.536	0.539	0.556
fev-bench	SQL skill ↑	50.39	49.42	48.99	44.42	47.28
fev-bench	MASE skill ↑	39.49	37.99	37.82	32.54	35.50

The margins over competitors are sometimes small, for example 0.658 versus 0.661 on GIFT-Eval MASE. The scaling within the family is notable: even the 28M model (GIFT-Eval MASE 0.678) comes close to larger rivals like Toto-2.0-2.5B (0.696), and the 123M model (0.659) is almost as good as the 209M model (0.658). The 5M model reaches 0.705.

What you need to try it

The model is very small. At 16-bit weights, 209M parameters take up roughly 0.5 GB, so any reasonably modern graphics card will do, and the Model Card also provides for running on a CPU. You need Python 3.10 or newer and torch 2.4 or newer; a few GB of memory is enough. The smaller variants run even more easily. Macs and Google Colab work fine with PyTorch, though long contexts (up to 32,768 steps) need more RAM.

Context

Time-series foundation models are a growing field, with Chronos-2, TimesFM and Toto competing. Mistral, best known for language models, entering this space shows the expansion into classic forecasting tasks in retail, energy and industry. On the critical side: all benchmark figures come from the vendor, the tech report hasn't been published yet ("coming soon"), and some of the leads are slim. The license is a modified MIT license with the condition that you don't infringe third-party rights. Check the license text before commercial use. Whether the models beat simple baselines on your own data is something you'll have to test yourself.

Terms explained simply

Time series: A sequence of measurements in chronological order, for example daily sales figures or hourly power consumption.
Zero-shot: The model makes predictions for new data without having been specifically trained or adapted for it beforehand.
Quantile: A value below which a given share of possible outcomes falls; the 0.9 quantile means 90% of outcomes are expected to lie below it. It's used to express uncertainty ranges.
Covariate: An additional influencing variable alongside the actual target series, such as holidays or weather.
Patch: A block of consecutive time steps (32 here) that the transformer processes as a single unit.
MASE: An error measure that compares forecast accuracy against a simple baseline method; lower is better.
CRPS: A measure of the quality of a probabilistic forecast that scores the entire predicted distribution; lower is better.

Sources

Hugging Face Trending huggingface.co
Lobsters – AI mistral.ai

#mistral#time-series#forecasting#foundation-model#open-weights

Read the original source

Try it yourself: Timestral-209M

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Timestral predicts how a series of numbers will continue, such as sales, energy consumption or sensor readings. You feed in the past and get back a median and uncertainty bands for the future, with no training on your side. You can also include extra information such as holidays.

Who is it worth it for?

Suited to analysts, developers and data scientists with time-series data who want a strong baseline fast. Not for you if you're looking for a chatbot or text model.

Size0.2 B parameters

Download0.8 GB (about 1 min at 100 Mbit/s)

Licensecustom license (see Model Card)

TypeTime series forecasting

Hugging Facemistralai/Timestral-209M

What your computer needs

Mac (Apple Silicon M1–M5) runsalso works on older Macs, Apple silicon is faster

CPU only (no graphics card) Runningusable without a graphics card, according to the developers – at least 4 GB of RAM

Storage approx. 2.8 GB freeModel download plus programs

For maximum accuracy, use 209M; according to the vendor, 123M is almost as good. 28M or 5M suit weak hardware or very large numbers of series. All of them also run on the CPU.

Inference runs through PyTorch on CPU or GPU; a big GPU isn't needed.
Requirements: Python 3.10 or newer and torch 2.4 or newer.
Very long contexts (up to 32,768 steps) and many variables increase memory use.
Also runs on Mac and in Google Colab via PyTorch.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program (mistralai/timestral on GitHub). The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The source doesn't mention Windows explicitly, but the model runs on CPU with PyTorch. The steps are adapted from the Linux instructions (PowerShell).

Check prerequisites. You need Python 3.10 or newer and Git. A graphics card isn't required. Check the versions in PowerShell.
```
python --version
git --version
```
Create a folder. Create a new, empty folder and switch into it.
```
mkdir timestral-test
cd timestral-test
```
Create a virtual environment. A virtual environment is a clean, separate Python space just for this project.
```
python -m venv .venv
```
Activate the environment. Afterwards, (.venv) appears at the start of the line. If PowerShell blocks the script, allow it for this window with the first command.
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.venv\Scripts\Activate.ps1
```
Install Timestral. This downloads the program from GitHub and needs PyTorch 2.4 or newer. It may take a few minutes.
```
pip install git+https://github.com/mistralai/timestral.git
```

Save the example script. Save this code as demo.py in the folder. The model (about 0.84 GB) is downloaded automatically on first run.

import numpy as np
import torch
from timestral import TimestralForecaster

model = TimestralForecaster.from_pretrained(
    "mistralai/Timestral-209M",
    device="cuda" if torch.cuda.is_available() else "cpu"
)

context = np.random.default_rng(42).standard_normal(1000).cumsum()
forecast = model.forecast(context, prediction_length=96)

print(forecast.median)
print(forecast.quantile(0.1))
print(forecast.quantile(0.9))

Run the script. You'll see three series of numbers with 96 values each.
```
python demo.py
```
Result. The script prints a forecast for 96 time steps: the median plus a lower and upper bound (10% and 90%).

macOS

macOS: not officially tested. The source doesn't mention macOS explicitly, but the model runs on CPU with PyTorch. The steps are adapted from the Linux instructions.

Check prerequisites. You need Python 3.10 or newer and Git. A graphics card isn't required. If Git is missing, macOS offers the Xcode tools the first time you call it: install them.
```
python3 --version
git --version
```
Create a folder. In the Terminal, create a new, empty folder and switch into it.
```
mkdir timestral-test
cd timestral-test
```
Create a virtual environment. A virtual environment is a clean, separate Python space just for this project.
```
python3 -m venv .venv
```
Activate the environment. Afterwards, (.venv) appears at the start of the line.
```
source .venv/bin/activate
```
Install Timestral. This downloads the program from GitHub and needs PyTorch 2.4 or newer. It may take a few minutes.
```
pip install git+https://github.com/mistralai/timestral.git
```

Save the example script. Save this code as demo.py in the folder. The model (about 0.84 GB) is downloaded automatically on first run.

import numpy as np
import torch
from timestral import TimestralForecaster

model = TimestralForecaster.from_pretrained(
    "mistralai/Timestral-209M",
    device="cuda" if torch.cuda.is_available() else "cpu"
)

context = np.random.default_rng(42).standard_normal(1000).cumsum()
forecast = model.forecast(context, prediction_length=96)

print(forecast.median)
print(forecast.quantile(0.1))
print(forecast.quantile(0.9))

Run the script. You'll see three series of numbers with 96 values each.
```
python demo.py
```
Result. The script prints a forecast for 96 time steps: the median plus a lower and upper bound (10% and 90%).

Linux

Linux: supported. According to the instructions, Timestral runs with PyTorch on CPU or GPU. An NVIDIA card (CUDA) is used automatically if present, but isn't required.

Check prerequisites. You need Python 3.10 or newer and Git. A graphics card isn't required. Check the versions in the terminal.
```
python3 --version
git --version
```
Create a folder. Create a new, empty folder and switch into it.
```
mkdir timestral-test
cd timestral-test
```
Create a virtual environment. A virtual environment is a clean, separate Python space just for this project.
```
python3 -m venv .venv
```
Activate the environment. Afterwards, (.venv) appears at the start of the line.
```
source .venv/bin/activate
```
Install Timestral. This downloads the program from GitHub and needs PyTorch 2.4 or newer. It may take a few minutes.
```
pip install git+https://github.com/mistralai/timestral.git
```

Save the example script. Save this code as demo.py in the folder. The model (about 0.84 GB) is downloaded automatically on first run.

import numpy as np
import torch
from timestral import TimestralForecaster

model = TimestralForecaster.from_pretrained(
    "mistralai/Timestral-209M",
    device="cuda" if torch.cuda.is_available() else "cpu"
)

context = np.random.default_rng(42).standard_normal(1000).cumsum()
forecast = model.forecast(context, prediction_length=96)

print(forecast.median)
print(forecast.quantile(0.1))
print(forecast.quantile(0.9))

Run the script. You'll see three series of numbers with 96 values each.
```
python demo.py
```
Result. The script prints a forecast for 96 time steps: the median plus a lower and upper bound (10% and 90%).

Try it

Forecast the next 96 hours of my power consumption from 1,000 historical measurements.

Predict weekly sales for the next 12 weeks and include known holidays as a covariate.

For my sensor data, give me the 10% and 90% quantiles as an uncertainty band.

If something goes wrong

The package is installed with `pip install git+https://github.com/mistralai/timestral.git`, not from PyPI.

Missing values must be marked as NaN.

Horizons longer than 1,024 steps are extended block by block using the median, so uncertainty may grow.

Check the license (modified MIT) before commercial use.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.

What it's about

What the model can do

Architecture

Benchmarks

What you need to try it

Context

Sources

Try it yourself: Timestral-209M

What can I do with it?

Who is it worth it for?

What your computer needs

Guide

Windows 10 / 11

macOS

Linux

Try it

If something goes wrong

Ask the AI assistant

Comments

More articles