Google TimesFM-3: Multivariate Forecasting That Beats the Benchmarks (with a License Catch)

Large language models are great at predicting the next word. For businesses, time-series forecasting models essentially try to do the same thing, but for data. Over the last few years, there has been a lot of work in building better forecasting models. Last year saw the launch of models like Chronos-2 from Amazon and Moirai 2.0 from Salesforce, while more recently, Datadog launched its Toto 2.0 model. On August 31, 2026, Google launched TimesFM-3: a 330-million-parameter model trained on over a trillion real-world and synthetic data points. It is Google’s first model that was natively pre-trained to handle multiple related time series with zero-shot generalization — and it can forecast multiple related time series in parallel, including historical data like past foot traffic.

1. Why Multivariate Matters

As Google research scientists Ayush Jain and Rajat Sen explain in the announcement, "most real-world forecasting problems are inherently multivariate: where multiple time series and auxiliary external features jointly impact the future forecast of a time series." Past sales only tell part of the story. A good forecast should also draw on sales of related products (e.g., ice cream cones, syrups), historical foot traffic, and known future events like weather forecasts, promotions, and holidays. TimesFM-3 is Google’s first model natively pre-trained to handle these multiple time series and do so with zero-shot generalization — no per-dataset retraining, just parallel forecasting across related series out of the box.

// TimesFM-3 is a decoder-only transformer that chops each
// time series into patches of 32 data points and treats
// them roughly the way a language model treats tokens.
// Google's researchers: "most real-world forecasting
// problems are inherently multivariate: where multiple
// time series and auxiliary external features jointly
// impact the future forecast of a time series."
const CONFIG = {
  "model": "timesfm-3.0-330m",
  "patch_size": 32,               // points per patch/token
  "attention": [
    "causal across time within a series",  // no future leak
    "cross-series at a given moment"       // promotion in one
  ],                                        // line informs another
  "pretrained": "1T+ real and synthetic data points"
};

2. Architecture: Patching + Dual Attention + Masked Decoding

Like its predecessors, TimesFM-3 is a decoder-only transformer that chops each time series into patches of 32 data points and treats them roughly the way a language model treats tokens. What’s new is that these tokens now flow through two alternating kinds of attention layers. The first looks backward across time within a single series and keeps things strictly causal, so the model can’t see values it shouldn’t know yet. The other looks sideways across all series at a given moment — which is how a promotion in one product line, for example, can inform the forecast for another. Decoding changed too. Earlier versions generated forecasts one patch at a time, which added latency and compounded errors along the way. Instead, TimesFM-3 appends masked placeholder tokens for the entire forecast horizon and fills them all in with a single forward pass.

// Zero-shot inference: past sales only tell part of the
// story. A good forecast also draws on sales of related
// products (ice cream cones, syrups), historical foot
// traffic, and known future events like weather forecasts,
// promotions, and holidays. TimesFM-3 ingests multiple
// series and forecasts them in parallel, out of the box.
from huggingface_hub import snapshot_download
import torch

model = TimesFm.load_pretrained("google/timesfm-3.0")
series = torch.tensor([
  [120, 132, 118, 141, 155],   # ice cream cone sales
  [98, 105, 101, 112, 119],    # syrup sales
  [430, 455, 470, 498, 512],   # foot traffic
])
horizon = 7
forecast = model.forecast(series, horizon=horizon)
# Returns parallel forecasts for all three series.

3. Benchmarks: Ahead Across the Board, Predecessor at the Bottom

In the benchmarks Google shared, TimesFM-3 outperforms all of these, often by a significant margin. The team looked at Salesforce’s Gift-Eval, Amazon/AutoGluon’s FEV-Bench, and TimeBench. What’s maybe the most surprising here is that TimesFM-2.5, which was state-of-the-art when it launched in September 2025, is now at the bottom of the benchmarks. That’s how fast this field is developing. For teams choosing a model, this means "last year’s best model" may no longer be a reasonable default — forecasting models now iterate almost as fast as foundation models themselves.

// Masked decoding: earlier versions generated forecasts
// one patch at a time, which added latency and compounded
// errors along the way. TimesFM-3 appends masked placeholder
// tokens for the entire forecast horizon and fills them all
// in with a single forward pass.
def forecast_all_at_once(model, context, horizon):
    n_patches = ceil(horizon / model.patch_size)
    seq = torch.cat([context, MASK.repeat(n_patches)])
    logits = model(seq)          # one forward pass
    return logits[context_len:]  # all horizon patches filled

4. The License Catch: Non-Commercial Weights

Google decided to launch the new model under a non-commercial license. That’s becoming a bit of a trend in the world of model builders. TimesFM-2.5 still shipped with the Apache 2.0 license — as do Toto 2.0 and Chronos-2. The TimesFM-3 source code is still under the Apache license, but Google notes that "for the time being, TimesFM 3.0 pretrained weights are distributed under the separate timesfm-non-commercial-license-v1.0 license and are restricted to non-commercial, non-production use. Commercial or production use of the default pretrained weights is not permitted." Google will soon replace TimesFM-2.5 as the model that powers BitQuery’s AI.FORECAST command, so the company is actively monetizing these models. Every player in this market already integrates its forecasting models into its own platform, but Google restricting the state-of-the-art weights while also opening a paid path through its data warehouse is a pretty clear signal of where these labs think the money is in the long run.

5. Code Walkthrough: Config, Zero-Shot, Masked Decoding, License, Benchmarks

The code blocks in this post unpack the model. Block one is the core config: 330M parameters, 32-point patches, two attention modes (causal within a series, cross-series at a moment), and trillion-scale pretraining. Block two is zero-shot inference: feed ice cream cone sales, syrup sales, and foot traffic together and forecast seven steps in parallel. Block three is masked decoding: append masked placeholder tokens for the whole horizon and fill them in a single forward pass, instead of generating patch by patch. Block four is the license check: source Apache 2.0, weights non-commercial, commercial path through BigQuery AI.FORECAST. Block five is the benchmark snapshot: Gift-Eval, FEV-Bench, TimeBench — beating Chronos-2, Moirai 2.0, Toto 2.0, with predecessor TimesFM-2.5 at the bottom.

// The license catch: source code is Apache 2.0, but the
// pretrained weights ship under the separate
// timesfm-non-commercial-license-v1.0 -- restricted to
// non-commercial, non-production use. Check before you
// build a product on it.
const LICENSE_CHECK = {
  "source_code": "Apache 2.0 (open)",
  "pretrained_weights": "timesfm-non-commercial-license-v1.0",
  "allowed": ["research", "evaluation", "non-commercial"],
  "forbidden": ["commercial use", "production use"],
  "commercial_path": "Google BigQuery AI.FORECAST (paid)",
};
// TimesFM-2.5 shipped Apache 2.0; Toto 2.0 and Chronos-2
// are Apache 2.0 too. Google restricting the SOTA weights
// while opening a paid path through its data warehouse is
// a clear signal of where the labs think the money is.

6. What It Means for You

For teams doing demand forecasting, capacity planning, and sales analytics, TimesFM-3 confirms a direction: multivariate zero-shot forecasting is mature enough to use out of the box — no per-dataset model training required. But before you adopt it, run three checks. First, licensing: the non-commercial weights cannot go straight into production; the commercial path today is Google BigQuery’s AI.FORECAST. Second, run your own benchmarks: vendor benchmarks are directional evidence; validate against your own data distribution. Third, watch the iteration cadence: if your forecasting model is still last year’s SOTA, you may already be running a bottom-of-the-benchmark model. The half-life of this field keeps shrinking.

// Benchmarks that matter: Google evaluated against
// Salesforce's Gift-Eval, Amazon/AutoGluon's FEV-Bench, and
// TimeBench -- and TimesFM-3 outperforms Chronos-2 (Amazon),
// Moirai 2.0 (Salesforce), and Toto 2.0 (Datadog), often by
// a significant margin. The shocker: TimesFM-2.5, SOTA when
// it launched in September 2025, is now at the bottom.
const BENCHMARKS = {
  "suites": ["Gift-Eval", "FEV-Bench", "TimeBench"],
  "beaten": ["Chronos-2 (Amazon)", "Moirai 2.0 (Salesforce)",
             "Toto 2.0 (Datadog)"],
  "note": "TimesFM-2.5 (Sep 2025 SOTA) now at the bottom --
          that is how fast this field is developing."
};