docs/sealed-runner.md

FUTURE-TS Sealed Runner

Status

MVP implemented in future_ts/sealed_runner.py; production hosted isolation is still future work. The local runner signs manifests, enforces CPU/wall-clock budgets, applies best-effort memory limits, and attempts Linux network namespace isolation. On non-Linux hosts the CLI prints a prominent warning: environment scrubbing is not structural isolation and raw sockets are not blocked.

Why it matters

Two capabilities in the benchmark only become credible once the runner is enforced:

• Efficiency (E). The capability vector's E dimension comes from per-prediction runtime_ms / memory_mb reports against each task's resource_budget. Without a sealed runner, those numbers reflect whatever hardware the submitter used. They are not comparable across models and should not feed a capability vector that users read as cross-model.
• Live tier integrity (blind_archive, live). The validation layer already requires platform_received_at <= earliest prediction issue_time, but that only checks timestamps the submitter declared. A sealed runner stamps those timestamps from the platform clock and the issue-time boundary is enforced by the platform, not self-reported.

Contract

A sealed runner MUST satisfy all of:

1. Fixed hardware class. Each task's resource_budget declares a hardware_class tier. The runner provisions exactly that class — same CPU model / GPU class / RAM / swap — for every submission evaluated against the task. Submissions that exceed the budget fail coverage, not silently run slower.

2. No network egress. The container has no outbound network. Tasks that require retrieval must provide a pinned retrieval snapshot mounted read-only; submissions that declare uses_external_retrieval=true without consuming a provided snapshot are rejected. The local subprocess runner only enforces this structurally on Linux with CLONE_NEWNET; macOS/Windows runs should use Docker/Kubernetes --network=none before treating a result as production-sealed.

3. Timestamps signed by the platform. platform_issued_at and platform_received_at are written by the runner, not the submission. platform_received_at is the wall-clock time the runner accepted the submission artifact. platform_issued_at is the wall-clock time the runner handed the task to the submission's forward function.

4. Deterministic seeding. The runner injects a fixed random seed derived from source_snapshot_id. Non-deterministic submissions (e.g. models that sample without respecting the seed) are rerun N times and the mean is reported with its own standard deviation.

5. Tamper-evident prediction log. Each prediction is appended to a log the runner signs before writing. The signed log is what prediction_hash is computed against. Submissions cannot retroactively edit predictions.

6. Resource-budget enforcement. Per-prediction runtime_ms is the platform-measured wall-clock for the forward call, not a submitter report. Exceeding task.resource_budget.latency_ms on more than X% of predictions fails the task (not just penalised via efficiency_score), where X is task-declared.

7. Archive-by-default. The runner uploads the predictions, run_manifest, and a bit-exact container digest to an artifact bucket. Any score can then be recomputed against the archived predictions (see future_ts recompute-metric) without re-running the model.

Submission surface changes

No new submission fields are required. The existing execution_mode enum already separates sealed from self_attested. What changes is the validator's interpretation:

• self_attested: accepted for public_dev tier. Submitter-declared timestamps. Submitter-reported runtime_ms/memory_mb may be used for E but must carry a self_attested provenance flag on any leaderboard surface.
• sealed: required for blind_archive and live tiers. Platform-signed timestamps and platform-measured resource usage. Leaderboard surfaces for E comparing across models SHOULD filter to sealed rows only.

The validation layer enforces sealed for the non-dev tiers today via requires_sealed in validation.validate_submission. That check gates the file format. What it does NOT enforce is that the numbers inside a sealed submission actually came from a sealed runner. Implementing that is the work this document frames.

Operational levels

The repository uses two file-format values (self_attested, sealed) but reviewers should distinguish four operational levels:

Level	Meaning
self_attested	Submitter ran the model and supplied timestamps/runtime. Useful for public development only.
local_sealed_mvp	The current subprocess runner: hashes, platform timestamps, CPU/wall-clock limits, best-effort memory, Linux network namespace when available.
hosted_sealed	Evaluator-run container or job with fixed hardware, no egress, immutable artifacts, and platform-measured telemetry.
hosted_attested_live	Hosted sealed execution plus pre-registered live waves and labels that did not exist at submission time.

Only the last two levels should be used for public claims about comparable E scores or externally attested live integrity.

Implementation sketch

Stage 1 (current MVP): a local subprocess runner that takes a Python entry point, mounts task windows in a scratch workspace, writes predictions to a signed output file, and produces the run_manifest from platform state. Linux attempts CLONE_NEWNET; other platforms warn that the network seal is not structurally enforced.

Stage 1b: optional Docker local backend. This should run the same contract in a --network=none container and use container or cgroup memory limits instead of Python resource limits. This is the recommended local path for macOS and Windows users who need enforceable isolation.

Stage 2: Kubernetes job per submission, with resource quotas enforced by the cluster (not just the container). Required for production blind_archive / live runs because local Docker cannot guarantee GPU isolation across tenants.

Memory limits in the MVP

The MVP uses resource.setrlimit for CPU and memory. It prefers RLIMIT_DATA for memory and falls back to RLIMIT_AS only when RLIMIT_DATA is not available. RLIMIT_AS caps virtual address space and can fail Python ML runtimes during interpreter startup or shared-library loading even when RSS is small. Production runs should rely on cgroups/Docker/Kubernetes memory limits instead.

Stage 3: a public submission endpoint. Accepts a container image URL + artifact_uri, provisions a runner, runs the evaluation, produces a signed BenchmarkReport, uploads predictions to the archive bucket, returns the report to the submitter. Until this stage lands, submissions are produced by the evaluator (TSFM.ai) running models on behalf of authors — which is how the reports/tsfm_ai_empirical_v2_multi_budget run was produced.

Open questions

• Should submitters be permitted to provide fine-tuning datasets inside the sealed container, or must PEFT/FT adaptation happen at submission time using a provided train split? (Currently ambiguous; the adaptation_budgets contract says the budget is part of the submission but does not pin where data came from.)
• What minimum hardware class does public_dev require to produce comparable E numbers? Current submissions run on whatever the author has. The sealed-runner work should pin this explicitly.
• How does the runner expose task-level actuals to the submission without leaking labels to models that might memorize them? One option: the runner hands the submission only historical context and an issue_time, never the future label; labels are matched post-hoc by the scorer.