t0-alpha

t0-alpha is an open-weights time-series forecasting foundation model from The Forecasting Company.

t0 is a transformer-based model that produces probabilistic multi-horizon forecasts and natively operates on multiple covariates. t0-alpha is the first public iteration of the model.

You can use t0 on Retrocast, The Forecasting Company's platform for forecasting on your own data and comparing forecasts across open-weight models.

Model family: t0-alpha (PyTorch/MLX) · ONNX FP16 · ONNX INT8 · Collection

t0 forecasting French national electricity demand in Retrocast. Data: Enedis open data.

Model Details

• Model name: t0-alpha
• Model family: t0
• Developer: The Forecasting Company
• Task: probabilistic time-series forecasting
• Architecture: decoder-style patch transformer
• Parameters: approximately 102M
• License: Apache-2.0
• Weights: https://huggingface.co/theforecastingcompany/t0-alpha
• PyTorch runtime: tfc-t0
• MLX runtime: tfc-t0-mlx
• Managed API: https://docs.retrocast.com/documentation/t0-alpha

t0-alpha is an alpha release intended for research, experimentation, and applied forecasting evaluation.

Intended Use

t0-alpha is intended for probabilistic time-series forecasting. It can be used for univariate and multivariate forecasting, forecasting with historical or known-future covariates and multi-horizon forecasting.

Known-future covariates can include calendar features, planned events, holidays, promotions, weather forecasts, or other external signals available over the forecast horizon.

Forecasts should be treated as probabilistic estimates, not guarantees.

Forecasting With Covariates

t0 leverages covariate information, in the past and future when available, to improve its forecast.

Data: Medic'AM, monthly drug reimbursements from the French national health insurance.

The Quickstart below shows the API for both a plain univariate forecast and a multivariate forecast that conditions on historical and known-future covariates.

Installation

Choose a runtime for the same original t0-alpha checkpoint:

PyTorch

pip install tfc-t0

Requirements:

• Python >=3.10
• PyTorch >=2.4

Optional extras:

pip install "tfc-t0[evaluation]"
pip install "tfc-t0[plot]"

MLX on Apple silicon

pip install tfc-t0-mlx

The MLX package uses the same gated model repository, loads its safetensors directly and does not install PyTorch. Accept the model terms and authenticate with hf auth login before the first download.

Quickstart

The model repository is gated. Before the first download, sign in to the model page and accept its access conditions. Then authenticate with a token from that same account that can read the model:

hf auth login

In a notebook, use from huggingface_hub import login; login() instead. For scripts and CI, set HF_TOKEN in the environment. Signing in to the website alone does not authenticate your Python environment.

The simplest path is a univariate forecast through predict:

import torch
from t0 import T0Forecaster

model = T0Forecaster.from_pretrained("theforecastingcompany/t0-alpha", token=True).eval()

context = torch.randn(4, 512)  # 4 series, 512 past timesteps
out = model.predict(context, horizon=64, quantiles=[0.1, 0.5, 0.9])
out.quantiles  # (4, 64, 3)
out.median     # (4, 64)

predict accepts PyTorch tensors and NumPy arrays.

MLX Quickstart

The MLX runtime deliberately follows the same forecasting interface:

import numpy as np
from t0_mlx import T0Forecaster

model = T0Forecaster.from_pretrained("theforecastingcompany/t0-alpha").eval()
context = np.random.randn(4, 512).astype(np.float32)

out = model.predict(context, horizon=64, quantiles=[0.1, 0.5, 0.9])
out.quantiles.shape  # (4, 64, 3)
out.median.shape     # (4, 64)

See T0 for MLX for feature coverage, compilation guidance and reproducible Apple-silicon benchmarks.

Forecasting With Covariates

Anything known over the past goes in context. Alongside the target, extra variates attend to it and are forecast together. Anything known over the future, such as calendar features, planned promotions, or weather forecasts, goes in future_covariates, shaped [B, F, context + horizon]; the model conditions on it but does not forecast it.

import torch
from t0 import T0Forecaster

model = T0Forecaster.from_pretrained("theforecastingcompany/t0-alpha").eval()

context = torch.randn(2, 512)                    # 2 series, 512 past timesteps
future_covariates = torch.randn(2, 3, 512 + 64)  # 3 covariates known over context + horizon

out = model.predict(
    context,
    horizon=64,
    quantiles=[0.1, 0.5, 0.9],
    future_covariates=future_covariates,
)
out.quantiles  # (2, 64, 3)
out.median     # (2, 64)

Batched Inference

import numpy as np
from t0 import T0Forecaster, batch_series

model = T0Forecaster.from_pretrained("theforecastingcompany/t0-alpha").eval()

daily = np.random.randn(180)    # one series, 180 past timesteps
store = np.random.randn(2, 96)  # one series of 2 variates, 96 past timesteps
hourly = np.random.randn(1024)  # one series, 1024 past timesteps

context, mask, group_ids = batch_series([daily, store, hourly])
context.shape  # (4, 1024) — variates stacked, right-aligned to the longest series
group_ids      # [0, 1, 1, 2] — `store`'s two variates are forecast jointly

out = model.predict(context, horizon=24, quantiles=[0.1, 0.5, 0.9], mask=mask, group_ids=group_ids)
out.quantiles  # (4, 24, 3)
out.median[0]  # the 24-step median forecast for `daily`

Integrations that prepare complete T0 inputs, including known-future covariates, can batch the native representation directly:

from t0 import TimeSeries

first = TimeSeries.from_array(context_1, future_covariates_1)
second = TimeSeries.from_array(context_2, future_covariates_2)
batch = TimeSeries.batch([first, second])

out = model.predict_from_time_series(
    batch,
    horizon=64,
    context_length=max(context_1.shape[-1], context_2.shape[-1]),
)

Here each context includes its batch axis, for example [1, V, T], and each known-future input is [1, F, T + horizon]. The output is ordered by the flattened target rows in batch.

For efficient inference at scale, look at Retrocast.

Input Contract

• context may be shaped (B, T) for batched univariate forecasting.
• context may also be shaped (T,); it is promoted to a single-row batch.
• context may be shaped (B, V, T) for multiple target variates.
• future_covariates, when provided, should be shaped (B, F, context + horizon).
• mask, when provided, holds MaskType values shaped like context: MISSING for an absent observation, PAD for a cell that only widens a shorter series out to the batch's width.
• NaN in context is read as an absent observation. Padding is the case NaN cannot express, so a batch of unequal-length series needs a mask (or batch_series) to declare it.
• Patches made entirely of PAD stay out of attention.
• group_ids, when provided, holds one id per row of the context; rows sharing an id are variates of one series and are forecast jointly.
• group_ids cannot be combined with future_covariates, which are addressed per sample.
• NaN in future_covariates is treated as missing.
• horizon must be at least 1.
• Requested quantiles must be non-empty, sorted ascending, unique, and in (0, 1).
• The model was trained to emit quantiles 0.1, 0.25, 0.5, 0.75, and 0.9.
• Requested quantiles are produced by inference-time interpolation when needed.
• Horizons up to 1024 timesteps are decoded in one forward pass.
• Longer horizons use autoregressive rollout.
• Returned forecasts are finite float32 tensors on the model's device.

Architecture

t0 is a decoder-style patch transformer.

It encodes each patch from values, within-patch time index, and validity mask. The transformer alternates causal time-axis self-attention with variate-axis group self-attention. Time attention uses time-aware rotary embeddings. Variate attention lets variates in the same sample attend to one another. The stack uses pre-norm RMSNorm blocks, SwiGLU feed-forward layers, and a quantile head.

At inference, target and historical variates are normalized with causal running statistics. Future covariates use per-row global statistics.

Evaluation

t0-alpha is reported on the GIFT-Eval leaderboard and the fev-bench leaderboard.

Users should also evaluate t0-alpha on their own historical backtests. Useful checks include quantile loss, CRPS, MASE, empirical quantile coverage, calibration, and breakdowns by frequency, horizon, domain, history length, and covariate availability.

Public API

• T0Forecaster: the model itself.
• Forecast: the object returned by the model.
• T0Config: the configuration of the model.
• MaskType: the reason a time step is masked out.
• batch_series: utility to batch time series of potentially different lengths.
• TimeSeries.from_array / TimeSeries.batch / T0Forecaster.predict_from_time_series: lower-level integration API for batching complete T0 inputs, including known-future covariates.

Lineage and Attributions

t0 builds on ideas from open-source forecasting models. We gratefully acknowledge:

• Toto by Datadog (repo) and Chronos-2 by Amazon (repo) for factorizing attention in the time and variates dimension.
• TiRex by NXAI (repo) for contiguous patch masking.

Code-level attributions are listed in NOTICE, all under Apache-2.0.

Environmental Impact

Training compute and carbon emissions are not currently reported.

Citation

@misc{tfc-t0,
  title  = {t0: A time-series forecasting foundation model},
  author = {The Forecasting Company},
  year   = {2026},
  url    = {https://huggingface.co/theforecastingcompany/t0-alpha},
}

License

Apache-2.0. See LICENSE and NOTICE.

Contact

For issues and bug reports, use the tracker for the relevant runtime:

• PyTorch: https://github.com/theforecastingcompany/tfc-t0/issues
• MLX: https://github.com/theforecastingcompany/tfc-t0/issues