Vivix IVI: A Runtime for Living Stories
Introduction
Real-time video generation models have advanced faster than anyone expected over the past year. Making their output compelling enough to watch for extended periods has proved far more difficult. The gap sits in a place that's easy to miss: producing a decent video occasionally isn't hard; producing one every single time is.
This document is about why that gap exists, how hard it is to cross, and why we believe Vivix IVI (Interactive Video Interface) provides the right architecture for closing it.
Three Paradigms of Video Generation
Let's lay out the map first. Based on the relationship between generation time (t) and output duration (n), mainstream video-generation systems can be grouped into three paradigms: offline generation (t > n: the full output becomes available only after generation is complete), real-time chunk generation (t ≈ n: short segments, typically five to eight seconds long, are generated sequentially through video-to-video continuation), and real-time streaming generation (content is generated continuously and responds to new input with sub-second latency, using causal attention so content can be generated and consumed simultaneously). The differences between these three paradigms shape every design choice downstream.
Beyond the three paradigms, there's a horizontal variable: human curation and cherry-picking. The more time spent cherry-picking, the higher the video quality; the higher the quality, the more watchable it becomes. This option is readily available in offline creation but largely unavailable in real-time generation. It's the pivot around which the rest of this document turns.
Today's Content Map
When you place mainstream video content formats side by side in the same matrix, everything that works today still sits inside the controllable region. The only row that falls outside it is the last one—the destination we are aiming for but have not yet reached.
| Content Format | Visual Source | Audio | Shot Structure | Direction | Watchability |
|---|---|---|---|---|---|
| Traditional long-form and short-form video | Filmed | Recorded or produced in post | Human-edited | Human-directed | High and controllable |
| Conventional AI-generated video | AI-generated | Added in post | Human-edited | Human-directed | Moderate and relatively controllable |
| AI video with native multi-shot and audio generation | AI-generated | Natively generated | Natively generated | Human-directed | High and controllable |
| Real-time AI video with a Real-Time Director | Generated in real time | Generated in real time | Orchestrated in real time | AI-directed in real time | Variable and not yet controllable |
The last row—full-stack real-time AI generation paired with a Real-Time Director—is our goal and the source of the difficulty.
Why Real-Time Video Is a Probability Game
Offline video creation can fall back on cherry-picking. A model whose outputs average 7/10 can realistically be sampled 100 times to yield one 9/10 output; humans pick that one and publish it, and the audience sees only the 9/10 result. The quality floor is lifted by human selection: the model doesn't need to be consistently excellent, just occasionally excellent.
Real-time video creation offers no such luxury. Generation is consumption—there is no second take. The same 7/10 model in a real-time setting delivers a 7/10 result directly to the viewer, with no opportunity to try again. To keep every viewing experience above an acceptable quality threshold, the model must maintain consistently high quality and an extremely low failure rate, with no opportunity for cherry-picking.
Offline creation also has an entire chain of human touch-ups—voice work, editing, and script polishing—that lifts the watchability floor. Real-time generation is fully automated and effectively one-shot. Audio quality, narrative coherence, pacing, and structural logic: any weak link goes straight to the user. The real gap isn't just the model's peak capability—it's how low the model's failure rate can get.
The Real-Time Video Creation Death Valley
When plotted, this gap forms a death valley. As you move from the offline end to the real-time end, watchability drops sharply first. Cherry-picking is gone. Post-production is gone. Creators lose much of their frame-level control. It only climbs back up once the model's average capability rises significantly and a sufficiently capable real-time orchestration layer sits alongside it.
Two familiar analogies apply directly: Autonomous driving did not jump directly to Level 5; Levels 2, 3, and 4 introduced capability and built trust progressively. Humanoid robotics will not jump directly to general-purpose embodied intelligence either; single-purpose systems must earn user acceptance first. Without intermediate forms, you can't cross the watchability red line. Any approach aiming for consumer-grade real-time AI content must first explain how that transition can happen gradually.
Vivix IVI: A Bridge
IVI (Interactive Video Interface) is our answer to that question. Rather than waiting for a 10/10 model to emerge, it brings offline generation, real-time chunk generation, and real-time streaming into a single experience, coordinated by a runtime that can direct stories as they unfold. In doing so, IVI combines the controllability of offline generation with the immediacy of real-time interaction.
All Three Paradigms Together
In IVI, offline generation, real-time chunk generation, and real-time streaming are not mutually exclusive modes; they are building blocks that can coexist within the same experience.
The three paradigms cover different ground. Offline video is cherry-picked and post-produced, providing the highest degree of control and a reliable quality baseline for key scenes. Real-time chunks are generated within a few seconds, trading raw quality for immediacy and bridging the gaps between major story beats. Real-time streaming responds to the viewer with sub-second latency, creating a personalized sense of presence that fixed clips cannot provide. Any one of them alone still leaves you in the death valley. Put all three together and you have a way out.
Building with IVI changes the way creators think. The moments that have to be stable (the opening, the turning point, and the ending) go into offline video. The transitions, the buildup, the beats that move the plot forward go into real-time chunks. The moments that have to react to the viewer (a question, a change in the viewer's expression, or a choice) go into real-time streaming. What the audience sees is continuous content with both a stable skeleton and live reactions, neither fully scripted nor fully random.
The three layers aren't hard-partitioned. A real-time streaming exchange can trigger an offline flashback; a real-time chunk can be fed back as input to the next offline render. IVI provides a shared runtime through which outputs from all three paradigms can trigger, splice into, or replace one another.
The Real-Time Director as a First-Class Citizen
Producing good frames is only one part of producing a good story. Storytelling also requires continuous judgment: who should speak at this moment, where to cut, whether to push the conflict forward or let it breathe. When these decisions are handled by separate systems without shared scene context, the story can fall apart at the seams.
These decisions are often folded into a prompt at the beginning of generation. But a real-time story continues to evolve as the scene unfolds, requiring ongoing decisions about narrative rhythm and what should happen next.
IVI makes the Real-Time Director a first-class component of the runtime, rather than treating direction as a fixed instruction given only at the start. The director tracks the evolving context, decides the next move, and orchestrates the three paradigms so they work together within the same scene. It does not intervene frame by frame; it intervenes only at moments that materially change the direction of the story. Video generation renders each moment; the Real-Time Director determines how those moments are sequenced, connected, and adapted as the story unfolds.
The Real-Time Harness Engine
Making the director a first-class citizen isn't enough on its own; a director operating without access to external tools or persistent context will quickly exhaust the available story space. A capable director must be able to access external material, retrieve resources on demand, and introduce new characters at short notice. IVI equips the director with that layer through the Real-Time Harness Engine.
The pattern is the same one that makes coding agents work: long-horizon tasks succeed because the agent can look things up, write things down, and execute things at any point along the way. IVI brings the same setup into a story runtime. During a scene, the director can initiate a web search to retrieve up-to-date information, use image-generation tools to create a new character's appearance, call language and voice models to generate and deliver new dialogue, or use a character-creation tool to turn an improvised role into a persistent character who can return later. These capabilities are not built into the video model itself; they are external tools invoked by the runtime as needed.
IVI's shape shifts with this layer in place. Previously, IVI functioned primarily as an interface that generated video from user input. With the Harness Engine, it becomes a runtime that can autonomously drive a story, determining what it needs, retrieving or generating the required resources, and integrating them into the scene as it unfolds. What the audience experiences is no longer a piece of generated content but a performance evolving in front of them, continuously drawing on new resources as the story evolves.
Conclusion
Every generational shift in content formats has been enabled by an integrated stack of interfaces, models, and systems—not by waiting for a single model to suddenly reach 10/10. The winning stack is the one that balances controllability with immediacy. IVI is our bet on how this transition will happen: a space where creators, models, and the Real-Time Director work together so stories can continue to live, adapt, and evolve in real time.