Datasets:

TSFM-ai
/

future-ts

This guide is for external authors who want to submit a time-series forecasting model to FUTURE-TS. It covers the contract, the file format, the sealed execution environment, and the review process.

There are two ways to submit today:

Sealed-runner submission (preferred). You provide a Python script that takes task windows and writes predictions. The evaluator runs it through :mod:future_ts.sealed_runner on an isolated machine with a fixed hardware class, no network, and platform-signed timestamps. Your model's integrity declarations are then structural, not attested.
Pre-scored submission. You run your model yourself and hand us a validated FUTURE-TS submission JSON with predictions, an execution_mode="self_attested" run manifest, and a pretraining manifest declaring the data your model was exposed to. This path works for the public_dev tier only; blind_archive and live require the sealed runner.

Contract — what every submission must declare

Every submission is a JSON document that conforms to schemas/submission.schema.json and carries:

Field	Required	Purpose
`metadata.submission_id`	yes	stable identifier; must not collide with any prior submission
`metadata.model_name`	yes	human-readable name shown on the leaderboard
`metadata.organization`	yes	your affiliation
`metadata.training_cutoff`	yes	the latest timestamp your model could have seen at training time
`metadata.frozen_at`	yes	when the model weights were frozen; must be ≥ `training_cutoff`
`metadata.pretraining_data_manifest`	strict-mode only	list of `{source_id, cutoff_date, notes}` declaring your pretraining corpora. Benchmarks with `require_pretraining_manifest=true` reject submissions without it — intentional, to avoid conflating "clean" with "undeclared"
`metadata.run_manifest`	yes	platform timestamps + prediction_hash + manifest_hash (the sealed runner fills this for you if you use it)
`declarations.no_manual_retuning`	yes	must be true — you did not tune to the evaluation set
`declarations.network_isolated`	yes	true when the forecast loop could not reach the internet
`predictions`	yes	one record per (task_id, issue_time, series_id, horizon_index, budget); point and/or quantiles and/or event_probability depending on task type

See examples/submissions/futurefm.json for a complete example.

Sealed-runner contract (preferred path)

Write one script that implements the run() entry point:

# my_submission.py
import json, sys
from pathlib import Path
def run(task_windows_path: Path, predictions_out_path: Path) -> None:
    windows = json.loads(task_windows_path.read_text())["task_windows"]
    predictions = []
    for window in windows:
        # window has: task_id, issue_time, series_id, horizon,
        # target_timestamps, history, budget.
        # Produce one prediction per (window, horizon_index).
        ...
    predictions_out_path.write_text(json.dumps({"predictions": predictions}, indent=2))
if __name__ == "__main__":
    run(Path(sys.argv[1]), Path(sys.argv[2]))

A working reference lives at examples/submissions/reference_seasonal_naive.py.

Declare your pretraining manifest. If you're submitting to a benchmark with require_pretraining_manifest=true, attach a non-empty pretraining_data_manifest. Absence is not treated as "no exposure" — it's treated as "not disclosed" and the benchmark will reject your submission. Being honest costs you nothing; hiding costs you the submission.
Submit via PR, following the template below. The evaluator runs your script through :func:future_ts.sealed_runner.run_sealed and scores the output under the standard pipeline.

Resource caps the sealed runner enforces (MVP):

CPU: 120 seconds per invocation.
Wall clock: 180 seconds per invocation.
Memory: 4 GiB best-effort local limit (RLIMIT_DATA when available; RLIMIT_AS fallback only when necessary).
Network: structurally unreachable on Linux when CLONE_NEWNET succeeds. On macOS/Windows the local runner only scrubs proxy-related environment variables and prints a warning because raw sockets are still possible. Use Docker/Kubernetes --network=none for enforceable local isolation outside Linux.

Need more? Open an issue describing the hardware class you need and why — the runner is designed to support multiple classes per task card (see resource_budget on each task JSON).

How to submit

1. Open a PR

Fork the repository.
Create a submission directory at submissions/community/<your-org>_<your-model>/.
Place your submission script at submissions/community/<your-org>_<your-model>/script.py.
Place an accompanying declaration JSON at submissions/community/<your-org>_<your-model>/declaration.json carrying the metadata + declarations blocks (no predictions yet — the sealed runner fills those after it runs your script).
Add a short README at submissions/community/<your-org>_<your-model>/README.md with the model description, artifact link, and any notes reviewers need.
Open a PR using the template .github/PULL_REQUEST_TEMPLATE/submission.md.

The PR is auto-validated by CI: the submission directory is checked for script.py, declaration.json, and README.md; required metadata and declaration fields are checked; and the script is smoke-tested against the sealed runner using a small synthetic task window. Once those checks pass, a human reviewer signs off and triggers the full evaluation.

2. (Optional) Pre-scored self-attested submissions

If you prefer to run your model yourself, you can produce a full submission JSON (predictions included) and attach it to the PR as submissions/community/<your-org>_<your-model>/submission.json. Note:

execution_mode must be self_attested.
public_dev tier only; blind and live tiers require the sealed runner because the temporal-integrity guarantees depend on the platform clock, not submitter-provided timestamps.
You must still declare the pretraining manifest.

3. What the reviewer checks

Schema validation passes.
no_manual_retuning=true.
training_cutoff <= frozen_at <= platform_received_at (automatically enforced by the validator; the reviewer verifies the dates are plausible).
Pretraining manifest is declared; source_ids are plausibly public (unusual or proprietary entries require a note explaining why).
The sealed runner produced a non-empty prediction set for every visible (task, issue_time, series, horizon) tuple — partial runs are rejected by the coverage check.
The model card referenced by artifact_uri is real and reachable.

Governance & license

Submissions are reviewed by TSFM.ai on a rolling basis. By submitting, you agree:

Your submission script + declaration may be archived in this repository (same Apache-2.0 license as the rest of the repo).
The evaluator may score your submission and publish the resulting BenchmarkReport on any public leaderboard.
You retain ownership of your model artifact itself — we only archive the submission script, declarations, and produced predictions, never model weights.

Reproducibility expectations

A submission is reproducible when, given the same task_windows.json, the sealed runner produces the same prediction_hash. If your model is intrinsically stochastic, seed it deterministically from FUTURE_TS_SEALED_RUNNER or a submitter-fixed constant. The leaderboard flags non-deterministic submissions separately so readers know whether a rerun would reproduce the score.

Where to ask questions

Open a GitHub issue on the repository with the submission-help label. We aim to respond within 3 business days.