You’ve just tried t0. To your surprise, it matches or beats your production system’s accuracy. Wow!
Then you start thinking about putting it into production. Data pipelines. Context engineering. Backtesting. Serving. Another system to operate. “Another research company that only ships models,” you think. “I’ll stick with my battle-tested production system.”
Think again. The Forecasting Company gives you a forecast factory. We combine best in class forecast accuracy with the tools to build and run production forecasting systems for each of your use cases. You define the task, choose the input data, and decide how the forecasts will inform your business decisions. Our system handles the data preparation, context engineering, forecasting, backtesting, and delivery.
SQL to SQL. Parquet to Parquet.
Connect a SQL database and receive forecasts back in the same database through a configured integration. Or send Parquet and receive Parquet. Urs and our agents handle the data preparation and context engineering; t0 produces the forecasts.
Related tables + snapshots
Local files or object storage
Aggregation + time alignment
Missing policy + context slicingPrepared history + supported covariates
Return Parquet or write through the configured database integration
Ready for downstream queries
Ready for downstream jobs
The returned forecasts carry the identifiers and timestamps your next query or batch job needs. Here is what that looks like for a parcel forecast.
Describe the forecast. Get the file back.
With The Forecasting Company, you declare what the data means and what you want to forecast. Suppose you need parcel arrivals at each depot, every half hour, for the next day. Your raw data consists of transactions: individual parcel scans with timestamps and depot identifiers. The forecast needs regular counts for each depot, joined with the corresponding weather data.
For the file workflow, put the scans in transactions.parquet and weather forecasts by depot in weather.parquet. Save this request as forecast.json:
{
"input": {
"source": {"uri": "inline://transactions"},
"has_gaps": true,
"columns": {
"occurred_at": {"kind": "time", "frequency": "30min"},
"depot": "identifier",
"parcel_count": {
"kind": "target",
"aggregate": "sum",
"impute": {"const": 0}
}
},
"covariates": [{
"schema": {
"version": "0.3",
"source": {"uri": "inline://weather"},
"columns": {
"valid_at": {"kind": "time", "frequency": "30min"},
"depot_id": "identifier",
"temperature": {"kind": "future", "aggregate": "mean"}
}
},
"on": [{"base": "depot", "attached": "depot_id"}, "time"]
}]
},
"context": "2w",
"prediction_length": "1d",
"quantiles": [0.1, 0.5, 0.9]
}
This request groups transactions by depot, sums parcel counts on a 30-minute grid, matches weather by depot and time, and uses two weeks of context to forecast the next day.
Example assumptions:
- Each scan has
parcel_count = 1. Zero filling assumes a complete transaction feed where no rows really means no parcels. - Timestamps are in UTC.
- The weather source covers both the history and forecast horizon with information available at the forecast cutoff.
Then send the files and request a Parquet response:
curl --fail --show-error \
'https://api.retrocast.com/v1/forecast?model=t0-gamma' \
-H "Authorization: Bearer ${TFC_API_KEY}" \
-H 'Accept: application/vnd.apache.parquet' \
-F 'query=@forecast.json;type=application/json' \
-F 'transactions=@transactions.parquet' \
-F 'weather=@weather.parquet' \
--output forecasts.parquet
Parquet in, Parquet out, in one API call. The system handles aggregation, joins, context slicing, batching, and t0 inference. The response includes identifiers, timestamps, and quantiles, ready for your application to read from forecasts.parquet. You have no customer-specific model to train, upload, or deploy. The Urs technical report explains how the preparation engine works.
Try it with sample data: the Parquet sources cookbook includes a runnable payload and an in-page example. The response formats recipe shows how to receive Parquet output.
The production work this removes
Traditionally, an ML forecasting model is trained on a large historical dataset—say, five years—but receives only a short recent window, such as the last two weeks, at inference time. Running the parcel forecast this way requires separate training and inference pipelines.
The data work starts with the same scans. Count them at the right resolution, roll depots up to regions when needed, and join signals from other databases, such as depot metadata, staffing plans, and weather. A bad join can double-count parcels. An empty bucket might mean zero parcels or a broken feed. That preparation has to stay correct as new data arrives.
The training pipeline constructs examples: two weeks of inputs paired with the following day’s targets, repeated across the historical dataset. Your team trains the model, evaluates it, serializes it, uploads a versioned artifact, and deploys a service that loads it.
A separate inference pipeline keeps the latest two weeks ready for each forecast, often with different jobs, storage, and update schedules. Both paths must agree on aggregation rules, feature order, scaling, missing values, and what was knowable at the cutoff.
Here is the traditional training and serving lifecycle in Python-style pseudocode. Each pipeline and service call represents infrastructure your team has to build or operate:
# 1. Scheduled training: prepare years of examples.
training_rows = training_pipeline.read_snapshots(years=5)
X, y = training_pipeline.make_examples(
training_rows, context_steps=672, horizon_steps=48,
)
model.fit(X, y)
artifact = serialize(model, training_pipeline.transforms)
artifact_store.upload("parcel-model/v17", artifact)
# 2. Deployment: load the exact published model version.
serving_model, transforms = deserialize(
artifact_store.download("parcel-model/v17")
)
# 3. Every forecast: a different pipeline supplies recent inputs.
snapshot = inference_pipeline.read_snapshot(as_of=cutoff)
inputs = inference_pipeline.make_features(
snapshot, context_steps=672, transforms=transforms,
)
forecast = serving_model.predict(inputs)
At 30-minute resolution, 672 steps are two weeks; 48 steps are one day. The five years shaped the model’s parameters. Each prediction still receives only the chosen input window, along with any explicitly supplied lags or summaries. Context engineering is built into the training examples, features, and target definition. Changing those choices can mean changing both pipelines, retraining, and releasing another artifact.
Compare the two systems below. The traditional system has a training path that produces a model artifact and a separate path that serves forecasts. With The Forecasting Company, a single API call covers data preparation and t0 inference. Your application supplies the request and consumes the result; it does not have to orchestrate joins, context slicing, or batching.
Fit feature transforms
to the serving runtime
Same feature order + scaling
Loads the selected artifact
or Parquet files
Slice history + signals
Run inference
or Parquet files
Change the context without changing your stack
With t0 already pretrained, context engineering moves into the request: what history and other signals should the model see for this forecast? In the API example, you set those choices explicitly. Our agents can compare alternative windows and signals through historical backtests, using the same data declarations.
To classify support tickets, a team might fine-tune BERT on labeled examples. With an LLM, it can instead supply instructions and examples, as GPT-3 demonstrated. Both start with pretrained models; the difference is whether the application adapts the weights or the inputs.
Training adaptation
- Labeled task examples
- Fine-tune pretrained BERT
- Task modelNew input → task output
- Years of historical data
- Train a forecasting model
- Forecasting modelFixed inference input: recent 2 weeks
- Forecast
Inference context
- Instructions + examples + retrieved documents
- Pretrained LLM
- Answer
- Selected history + covariates
- Pretrained t0
- Forecast
For the parcel forecast, two weeks show recent levels and weekday patterns. A window of 52 or 104 weeks provides roughly one or two years of history, bringing annual peaks and earlier operating conditions into view. Change "context": "2w" to "context": "104w". The system prepares the longer input window through the same workflow.
Try changing the window and resolution below.
The weather join above is one context choice. A holiday calendar or planned closure may also help explain parcel arrivals. Declare the source and how it joins; Urs aligns it with the target series. The covariate cookbook shows how.
Backtest with the same preparation
A longer window or another signal is useful only if it improves the forecast. Explore forecasts and backtests on your own data in Retrocast. To compare context choices through the API, reuse the forecast specification at the same historical cutoffs and time resolution. The system shifts the context windows and runs the backtests. Request a JSON response with metrics, as in the backtesting recipe.
Historical runs require the source versions that were available at each cutoff. A weather forecast issued later, a late parcel scan, or a corrected staffing plan must not enter an earlier backtest. A timestamp filter alone cannot recover those versions. With the appropriate snapshots, the same declared aggregations, joins, and missing-value rules apply in evaluation and production. Our agents can then compare forecast accuracy alongside the time needed to prepare and return each result.
For the parcel job, your team supplies access to the data, defines the forecast, and chooses a destination. The product prepares the inputs, runs forecasts and backtests, and delivers a file or table that your depot planning application can consume. Adopting t0 gives you a route from the accuracy test to that daily workflow.
Start with the Parquet cookbook, or talk to us about connecting your database.