FAST World
live · flagshipA complete free ad-supported streaming TV stack — origination, monetization and a live viewer — packaged as a long-horizon RL environment for coding agents. Three real systems cooperate to put four live channels on screen; an agent has to operate all of it.
All three systems run in production today: forge.ventunotech.com · ssai.ventunotech.com · fastworldtv.ventunotech.com. The world image is a certified snapshot of these live products.
Home Cooking, Yoga & You, Art All The Way and Ventuno Mix — all four stream from ChannelForge end to end: live HLS playout plus real XMLTV EPG.
The SSAI ad server inserts real ad creatives — served as genuine video, not pass-through — into real SCTE-35 breaks on all four channels, delivered as one continuous HLS stream. VAST tag ingestion and server-side tracking are live too.
A viewer / operator toggle reveals the live pipeline under the TV — playout, SCTE/SSAI, HLS packager, EPG, origin and telemetry — as the environment an agent operates.
A replayed agent diagnoses and repairs a fault — missing asset, schedule collision, rights-window, stream degradation — while the channel keeps playing.
Channel-switch p50/p95, startup, concurrent viewers and errors — real, aggregated and persisted; surfaced in an Under-the-Hood dashboard and an open API.
744 ChannelForge API (plus 1 documented environment exception), 201 SSAI and 75 viewer tests, green inside the certified image · a shared /contracts golden suite (v1.1.0) binding the services · seed-deterministic ad decisions · copy-mode playout (~0.02 vCPU/channel, ~100× density) · three-tier never-dead-air fallback.
The internet-native version of lean-back TV.
A viewer opens a channel and watches always-on, scheduled programming — no subscription — funded by advertising. It feels like traditional television: channels, a guide, breaks, continuous playback.
But the stream a viewer sees is the output of a chain of systems that each have to be correct — and stay correct, around the clock.
ChannelForge originates, the ad server monetizes, FAST World TV presents.
ChannelForge never decides ads; the ad server never computes the schedule; the viewer computes neither. That clean separation across three cooperating systems is exactly what makes FAST World a serious world — an agent has to reason across services, not patch one file.
A direct (no-ads) HLS path also serves previews and the marketing player. The guide always comes from ChannelForge — never recomputed downstream.
The channel: schedule, media conditioning, playout, the HLS delivery origin (with SCTE-35 ad avails) and the EPG. The source of truth for what's on, now and next.
visit live →Ad decisioning and server-side stitching: detect the avails ChannelForge signalled, decide what fills each break, splice ad and slate media into the viewer's manifest, and record playback → analytics.
visit live →The viewer: a public FAST destination — player, now/next, timeline EPG, channel switching. Presentation only; it treats ChannelForge as the source of truth.
visit live →The live links go to the products this world is built from. Tasks run against the sealed 0.1.9 image, so the faults they plant exist only in that copy, not in the live services.
A product on top, an environment underneath.
The live demo is a working consumer FAST service that turns inside out on demand — the same page a viewer enjoys is the environment an agent operates.
Real ad creatives fill the breaks on all four channels; agent runs are replayed, recorded traces today, with a live agent-repair backend next.
A living operational system.
Time, state, contracts, failures and business rules — all at once, across three products, around the clock.
A bug may only surface at 2:00 AM, during a rights-window transition, or when a schedule rolls over.
A channel moves from draft → validated → published → live → monitored → reconciled.
Media analysis, scheduler, EPG, playout, ad markers, monitoring and reporting all have to agree.
Missing files, bad durations, broken metadata, invalid ad breaks, expired rights, repeated content and stale schedules.
A technically valid schedule can still violate programming strategy, sponsor rules, rights or distribution requirements.
Pull it, run it, reset it.
The world ships today as a certified, versioned image that runs under Harbor; signed private-registry delivery is being provisioned. Bring it up with a container adapter, run tasks against it, and reset to a clean, seeded state between episodes.
Seeded ad decisions and a reproducible baseline — the same seed yields the same run, and every fresh boot fingerprints identically (20/20).
Certified by difference against the previous certified image: 20/20 repeatable boots, a 2h soak (flat memory, 0 zombies, a clean stop and a healthy restart), the three repos' own test suites green, tini as PID 1, offline and no-network-capable. Trivy: no OS-package findings; one high finding in a vendored app's pinned dependency carries a documented not-affected exception.
The world, turned into an agentic eval bench.
A hermetic image bundles all three products at pinned commits. Each task injects a real defect or stubs a real feature; a held-out behavioral verifier grades pass/fail; the whole thing runs offline from a reproducible worldspec. Most tasks are the actual bugs and features we shipped, and the frontier challenge variants place a real operational condition in the running system — so the ground truth and the difficulty are real, not invented.
HLS manifests, SCTE-35, VAST, XMLTV — wrong-but-plausible is easy; correct needs the spec-shaped code read properly.
The origin's program-date-time timeline lags wall-clock and breaks sit at the edge of a sliding window; agents that don't model time fail.
A break_id threads avail → DATERANGE → SSAI → reconciliation across three repos and three languages. Cross-repo tasks put the defect on both sides of a service seam — can the agent hold the whole system in its head?
Whether an agent investigates the live system deeply enough to discover the operational facts a correct implementation depends on — facts that sit in the running environment, not in the ticket.
CORS preflight, sendBeacon content-types, reverse-proxy ordering — debugging from a real symptom, not writing a feature.
Two multi-step missions run deterministic scenarios across the whole stack — milestone-graded on partial credit, so drift and dropped context show up as a lower vector, not a single pass/fail.
The first long-horizon mission: a deterministic scenario driver walks the agent through a multi-step operational run across the whole stack, scored on a partial-credit milestone vector rather than one pass/fail.
Quartile beacons record zero events — fix the sendBeacon preflight and the server's body parser, on both sides of the seam.
Make break ids globally unique and thread them so reconciliation matches SSAI deliveries — zero orphans.
Emit CUE-OUT/CUE-IN alongside DATERANGE and size the live window so both stay visible across the break.
Repeat ads in order to fill a break, slate only the tail, always terminate.
Resolve documented VAST macros per-avail, reject undocumented ones, never emit PII.
XMLTV stop times must reflect break-extended aired duration and stay DTD-conformant.
Serve the manifest a fixed number of segments behind the live edge so stitched ads reliably land.
A CORS preflight returns 401 — make OPTIONS succeed while normal requests still authenticate.
★ Headliners — if a model can do these it genuinely understands the system: the long-horizon mission, the cross-repo beacon debug and the break_id cross-service contract.
The bench has 120 active tasks on the certified 0.1.9 image, plus two public sample tasks: seven capability sets (A–G), a hard tier, cross-repo tasks that span two or more repos, and two long-horizon missions, plus a frontier challenge tier under review. Superseded or defective tasks are retired, not patched over (15 so far). It's domain-specific to streaming / adtech — a feature, since that's underrepresented in existing benches — and authored by us, which is exactly why the held-out verifiers, the sealed gate and the pass audits are non-negotiable.
Pull it into your own stack.
The world ships as a certified, versioned image and runs under Harbor today (signed private-registry delivery is being provisioned); standard environment interfaces come through adapters, so you run it inside your own training and eval loop. No Ventuno framework required. OpenEnv and HUD adapters are on the roadmap.
Grading travels with the world: every task carries a programmatic, hidden verifier that returns a reward and verdict — whatever harness runs it.
We run the world before you do.
We run each world across a range of models, from a floor model to the frontier — both to show the tasks discriminate real capability, and to pressure-test and harden them. Success rates by model, a capability breakdown, the failure modes behind the numbers, and inspectable trajectories are shared with prospective licensees, not published publicly.
Licensing a world and want to see how it separates the models? request the results.
What you get, and what we keep sealed.
Every task is assigned a split before it ships. The split decides whether its grader ever leaves our infrastructure.
Training (39) and development (61) tasks: instructions, environments and graders ship with the licensed image, so you can train and iterate inside your own stack.
Held-out tasks (18, plus the frontier challenge tier) whose graders never leave our run server. We run your model against them and return scores; task details and failure forensics are shared only after your evaluation, so it stays uncontaminated.
- Overview, the two public sample tasks, their documents and verified results (the sample pack)
- With any lab, without an NDA, to evaluate FAST World. Not for redistribution.
- Model trajectories for the sample tasks (turn-by-turn JSON files)
- Only under an NDA, or a cover letter, with an evaluation-only clause: third-party model outputs, not licensed for training or fine-tuning any model, and not for redistribution.
- A guided demo of the running world
- Under NDA.
- The world image, the task catalogue and its graders
- Under a definitive agreement (an evaluation or RL training licence).
- 01Sample packTwo complete sample tasks — instructions, environments, hidden graders, reference solutions — with their gate results and verified model results. Shared with any lab, without an NDA, to evaluate FAST World.✓ live
- 02World CardThe certified image, its capability sets and the grader-trust proof, on one page.✓ live
- 03WalkthroughA live session: boot the world, reset it, run the grader gate, read the score.✓ live
- 04SandboxRun a curated demo task on our infrastructure and get a score back.○ planned
- 05Private evalWe run your model on held-out tasks and share scores and trajectories under NDA.◐ partial
- 06LicenseThe versioned image plus training and development tasks, delivered through a private registry (being provisioned).◐ partial
Start at step one: request access.
Start with a two-week evaluation.
In two weeks you get a measured, replay-verified view of where your model stands on a real production system.
- › Boot the world from the certified image: playout, ad server and viewer come up from a clean, seeded baseline.
- › Re-run the certification: each check is a command with an expected output, with evidence committed.
- › Grade the two public sample tasks both ways — no-op scores 0, the reference fix scores 1 — and read their wrong designs and tamper cases, which score 0.
- › Audit a run: full trajectory, per-rule grader breakdown and SHA-256 hashes of every file.
- › Replay a failure: rebuild a model's patch from its own trajectory and grade it natively.
request access or write to subbu@ventunotech.com.
Build agents that can handle the real thing.
Working with foundation-model labs, coding-agent companies, computer-use teams and post-training researchers.