t0-beta

t0-beta 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-beta is the second public iteration of the model.

It predicts 21 quantile levels natively, and is an incremental improvement over t0-alpha.

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-beta (PyTorch/MLX) · t0-gamma · t0-alpha · Collection

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

Requires tfc-t0>=0.5.0 (PyTorch) or tfc-t0>=0.6.0 (MLX)

t0-beta normalizes its inputs differently from t0-alpha, and the convention is carried in config.json as scaler_eps and scaler_eps_mode. Earlier releases do not read those fields: they load these weights without error and run them under t0-alpha's normalization, which silently degrades the forecast. Pin the runtime:

pip install "tfc-t0[torch]>=0.5.0"   # PyTorch
pip install "tfc-t0[mlx]>=0.6.0"            # MLX, Apple silicon

Model Details

• Model name: t0-beta
• Model family: t0
• Developer: The Forecasting Company
• Task: probabilistic time-series forecasting
• Architecture: decoder-style patch transformer
• Parameters: approximately 256M
• License: Apache-2.0
• Weights: https://huggingface.co/theforecastingcompany/t0-beta
• PyTorch runtime: tfc-t0[torch] >=0.5.0
• MLX runtime: tfc-t0[mlx]>=0.6.0 (Apple silicon)
• Managed API: https://docs.retrocast.com/documentation#available-models

t0-beta is a beta release intended for research, experimentation, and applied forecasting evaluation.

Intended Use

t0-beta 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-beta checkpoint. Both local runtimes ship in the tfc-t0 package, each behind an extra; a bare pip install tfc-t0 installs neither runtime: choose one with its extra.

PyTorch

pip install "tfc-t0[torch]>=0.5.0"

Requirements:

• Python >=3.10
• PyTorch >=2.4

Optional extras:

pip install "tfc-t0[evaluation]"   # includes the PyTorch runtime
pip install "tfc-t0[torch,plot]"

MLX on Apple silicon

pip install "tfc-t0[mlx]>=0.6.0"

🚀 Quickstart

The simplest path is a univariate forecast through predict:

import torch
from t0 import T0Forecaster

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

context = torch.randn(4, 512)  # 4 series, 512 past timesteps
out = model.predict(context, horizon=64, quantile_levels=[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-beta").eval()
context = np.random.randn(4, 512).astype(np.float32)

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

See the MLX runtime 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-beta").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,
    quantile_levels=[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-beta").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, quantile_levels=[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(
    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.

Converting your data to TimeSeries

TimeSeries is the model's native input. It holds target rows, known-future covariate rows, a mask and group ids, all on one width. predict builds one for you from a raw array. You only need to construct one yourself to batch inputs of different widths, or to call forward directly.

from t0 import TimeSeries

# context only, with `horizon` marking the region to predict
model_input = TimeSeries.from_array(context, horizon=24)          # context: [B, V, T]

# with known-future covariates, whose width sets the horizon
model_input = TimeSeries.from_array(context, future_covariates)   # covariates: [B, F, T + 24]

out = model.predict(model_input, horizon=24, quantile_levels=[0.1, 0.5, 0.9])

predict infers context_length from where the forecast region starts. Pass it explicitly when batching series of different widths. forward takes the same TimeSeries and runs a single differentiable pass over it, with no rollout. That is the entry point for fine-tuning.

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,), which 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 21 quantile levels: 0.05 to 0.95 in steps of 0.05, plus 0.01 and 0.99 at the tails.
• Requested levels between the trained ones are interpolated; levels beyond them follow exponential tails pinned through the outermost trained levels.
• 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.

Evaluation

t0-beta improves on t0-alpha on every benchmark we report. Lower is better for CRPS and MASE; higher is better for skill score.

Users should also evaluate t0-beta 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.
• VariateType: whether a row is a target, a historical covariate or a known-future covariate.
• batch_series: utility to batch time series of potentially different lengths.
• TimeSeries.from_array / TimeSeries.batch: build the model's native input, including known-future covariates and an explicit forecast horizon. predict accepts either a TimeSeries or a raw context array.

🧬 Lineage and Attributions

t0-beta continues the line started by t0-alpha, the first public iteration of t0, and keeps its architecture and interface.

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.

📚 Citation

t0 is described in t0: A Time-Series Foundation Model for Forecasting with Context. If our model is useful, please cite:

@article{meyer2026t0,
  title   = {$t_0$: A Time-Series Foundation Model for Forecasting with Context},
  author  = {Meyer, Lucas and Sole, Claudio and Xiang, Huikan and Li, Nicolas and Franceschino, Lucas and Quera-Bofarull, Arnau and Scholl, Maarten P. and Fainberg, Joachim and N{\'e}giar, Geoffrey},
  journal = {arXiv preprint arXiv:2609.24559},
  year    = {2026},
  url     = {https://arxiv.org/abs/2609.24559},
}

⚖️ License

Apache-2.0. See LICENSE and NOTICE.

Contact

For issues and bug reports, use the tracker at https://github.com/theforecastingcompany/tfc-t0/issues.