The same quantiles can predict three different futures

A forecast can get every future hour's median and quantiles right and still be unable to answer a basic operational question: will the trajectory cross a danger threshold? Yao and colleagues build PathFM to generate coherent multivariate futures directly. Their strongest lesson is more general than the architecture: a stack of marginal forecasts is not a distribution over paths.

Consider four binary future steps. At every step, zero and one each have probability one half. We can complete those identical marginals in at least three ways: draw each step independently; draw one rank and use it everywhere (the comonotone, or perfectly aligned, case); or alternate between zero and one. Each completion predicts an expected total of two. Everything else can change.

def summarize(paths):
    totals = [sum(path) for path, _ in paths]
    mean = sum(w * total for total, (_, w) in zip(totals, paths))
    variance = sum(w * (total - mean) ** 2
                   for total, (_, w) in zip(totals, paths))
    hit = sum(w for path, w in paths if 1 in path)
    transitions = sum(
        w * sum(path[t] != path[t - 1] for t in range(1, len(path)))
        for path, w in paths
    )
    return mean, variance, hit, transitions

The page executes the TypeScript implementation above against exact, finite ensembles. There is no simulation error and no randomness. The Python and C++ variants perform the same reductions line for line.

PathFM tokenizes multiple time-series channels, conditions on history, and uses conditional flow matching to transform simple noise into an entire future trajectory. Flow matching trains a velocity field along a path from noise to data; at inference, an ordinary differential equation solver follows that field. Because one draw is a whole trajectory, its temporal and cross-channel dependence is explicit rather than reconstructed after marginal forecasting.

The authors evaluate 94 tasks with fps-bench, a benchmark whose components reward calibrated paths, dependence, sums, maxima, and first-passage behavior. Scores are normalized so higher is better. PathFM uses 32 sampled paths in the reported comparison. Its 126-million parameter model generates those 32 paths in 51.6 ms on an Nvidia L4, according to the paper.

Quantile models do not emit paths, so the benchmark must manufacture them. The independent completion draws a separate quantile rank at each time and channel. The comonotone completion shares one rank everywhere. Both preserve every marginal quantile, yet TimesFM-3's aggregate FPS falls from 0.4871 to 0.4590. Curiously, its sum score moves slightly the other way: 0.5032 to 0.5049. No completion dominates every functional.

This does not weaken PathFM's central result; it clarifies it. The generative model is being rewarded for learning an object that marginal forecasters leave unidentified. But practitioners should report which completion a quantile baseline uses, show component scores rather than only their aggregate, and test intermediate copulas or historical-rank resampling instead of treating two extremes as exhaustive.

First, increase the number of sampled paths and plot score uncertainty: 32 draws may be fast, but rare first passages and tail maxima can be noisy. Second, evaluate decision regret for applications whose costs are known, rather than assuming the six FPS components have the right weights. Third, stratify by horizon and dependence strength. Finally, compare native paths with calibrated copula completions built from the same marginal model. That isolates whether gains come from better marginals, better dependence, or both.

Architecturally, PathFM belongs beside the site's interactive Transformer walkthrough. Conceptually, its lasting contribution is simpler: if the action depends on a path, evaluate and model a path.