Generative Video at the Speed of Light

The 2023 clip of Will Smith eating spaghetti is an immediately recognizable starting point for generative video: distorted motion and imagery that nobody would confuse with reality. Sora in 2024 brought a substantial improvement, followed by Sora 2 and then Seedance, whose output Keegan McCallum describes as photorealistic. That progression makes visual quality the obvious axis on which to judge new models.

But an interactive application needs more than a convincing finished clip. It needs video that arrives quickly enough to consume as it is generated, and that can continue rather than stop after a short shot. McCallum, who introduces himself as the founder of uRun, an inference provider for interactive media, shifts attention to efficiency and long-horizon generation: capabilities that determine whether video can become an interface.

The Helios demonstration separates two useful capabilities. In the bottom-right corner, one generation runs continuously; elsewhere, a collection of clips is generated faster than a viewer can consume them. McCallum puts their quality near that of the previous year's frontier models. He describes Helios as a distillation of Wan 2.1 14B. More precisely, its technical report describes architectural adaptation and token compression before distillation; the distilled checkpoint is distinct from Helios Base.

The next comparison asks the audience to distinguish a real-time result from one that took minutes to generate. Its complete reveal labels two portraits of women surrounded by flowers, using the same prompt and the same H100:

McCallum judges the right-hand result to have arguably better motion and reports about one-hundredth of the cost. The displayed frame rates measure throughput; the talk does not give the billing calculation behind that cost comparison.

The subsequent charts address quality for both short and long video generation. Helios had arrived in March, making it a recent example of how quickly the efficiency frontier was moving. The important combination is sustained output and useful visual quality: speed opens up interaction only if the generated scene remains worth watching.

These capabilities extend beyond one model family:

• World models maintain consistency over long horizons while exposing fine-grained camera and viewport controls.
• Avatar models, such as those from LemonSlice, provide a conversational visual presence.
• Video-to-video models transform incoming imagery in real time, creating the effect of a magic mirror.

Each offers a different kind of interaction: navigating a scene, engaging with a character, or changing the appearance of a live input.

McCallum reports at least forty model releases that year across the emerging real-time and long-horizon video ecosystem. To put the economics in familiar terms, he asks who has spent $10 or $50 in an hour using Claude Code. He estimates that, with most of these video models, $10 buys three hours of continuous generation and $50 buys fifteen hours. Those are his usage estimates, without model-specific rates or billing conditions; the spoken fifteen-hour figure makes the slide's “full day” comparison concrete. The resulting opportunity is sustained visual interaction rather than purchasing isolated clips.

A magic mirror starts with a webcam feed and changes what the user sees. McCallum's examples include trying an outfit, seeing yourself in a car you like, or previewing a haircut. Because the transformation is open-ended and happens on live input, the interface could support exploration while the user moves and reacts, rather than requiring a separate image-generation request for each variation.

That visual medium also suggests an accessibility opportunity. Much of today's AI interaction demands reading and writing, which can be difficult for some users and a poor fit for people who think or learn visually. Companions and other visual interfaces could let more people experience the benefits already familiar to coding-model users. This is a proposed direction for interface design, not an accessibility outcome demonstrated in the talk.

Content creation has often followed a slot-machine workflow: write a prompt, perhaps supply keyframes, generate a result, and try again if the shot misses. McCallum describes spending about $10 per minute trying to obtain the desired shot, without specifying a provider or billing basis. The creative problem is the separation between asking and seeing: the user discovers what to change only after committing to a generation.

McCallum says these models can respond to steering in under a second while generation continues. That changes the workflow into an ongoing feedback loop. A creator could pilot an agent, watch over its shoulder as it generates, and adjust the direction while the scene develops. The control becomes more granular because observation and intervention happen during the same generation.

He then points to Google Gemini Omni as a way to render a more fully realized clip from that creative process. The proposed division of labor is useful: explore and direct with fast output, then produce a higher-fidelity result. Google's video-generation and editing demonstrations support the product reference, though the talk does not demonstrate an integrated refinement pipeline. McCallum's invitation is to consider applications beyond the familiar examples of navigating generated worlds.

Delivering that experience introduces several connected engineering requirements:

1. Place GPU capacity near the audience. A global application may need GPUs in multiple regions.
2. Route users to serving capacity. Each connection needs an appropriate destination and a GPU to run its workload.
3. Establish media transport. McCallum names WebRTC, ICE and TURN as parts of the connection setup.
4. Connect models into continuous workflows. More ambitious applications need several models working together through a real-time harness.
5. Synchronize controls with frames. User input must stay coordinated with generated output while the application maintains a smooth stream.

The last two requirements make this more than an endpoint that returns a video file. The application must coordinate computation, controls and media throughout an active session.

uRun's proposed application boundary is a drop-in React component that provides interactive video while hiding the serving machinery. Behind it, McCallum describes a programmable Python runtime for composing complex pipelines with asynchronous generation. Avatar applications and live video transformations are two intended uses of that split: the frontend handles the user's interaction, while the backend coordinates the models.

For the webcam example, a minimal Python pipeline can express the composition with asynchronous iteration. The following application-level function accepts incoming frames, a transformation function and an output sink; it is not a uRun SDK signature:

from collections.abc import AsyncIterable, Awaitable, Callable
from typing import TypeVar

Frame = TypeVar("Frame")

async def transform_webcam(
    frames: AsyncIterable[Frame],
    transform: Callable[[Frame, str], Awaitable[Frame]],
    send: Callable[[Frame], Awaitable[None]],
    current_prompt: Callable[[], str],
) -> None:
    async for frame in frames:
        prompt = current_prompt()
        transformed = await transform(frame, prompt)
        await send(transformed)

The prompt is sampled for each input frame, and each transformed result is sent before the next frame is processed. That preserves ordering in this small pipeline while allowing the prompt to change between frames. GPU scheduling, media transport and tighter synchronization remain responsibilities of the surrounding runtime. The abstraction makes the model operation programmable without making the application author implement every part of the streaming service.

The final layer is tooling for agents that build applications. McCallum argues that platforms in 2026 also need to function as software factories, with interfaces that agents can use directly. He says uRun has built CLI and MCP server access for constructing these interactive video applications. These are capabilities presented in the talk; the public overview does not establish their current API contracts.

The frontier is increasingly in how the models are served. Continuous generation becomes a usable medium when users can connect, steer it and receive coherent output without managing the underlying GPU and streaming systems themselves. McCallum closes by seeking design partners who want to push human-computer interaction in that direction, alongside an invitation to join uRun.