A title card reading Pika Enact, subtitled a research preview you cannot use yet, with three chips reading announced 18 November 2026, built on Pika H3 Flex, and 1.8x faster than playback, plus two cards contrasting Live Staging at under 0.4 seconds response on an H100 against Live Camera Control at 640x480 on eight B300s.
Guides & Insights

Pika Enact Generates Faster Than It Plays — and You Can't Use It Yet

Author

Elias Hawthorne

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

The sentence that matters in Pika's announcement of Pika Enact is not the one about dragging actors around with a mouse. It is this: "Currently, Enact is a research preview, unavailable for consumer use." There is no waitlist, no sign-up, no pricing page and no demo build. The only route in the post is an email address for enterprise conversations. Everything else — the three directing modes, the latency figures, the eight-B300 node — describes something you can read about on 19 November and cannot touch.

That is worth writing about anyway, because of what Enact is built on. The system runs on Pika H3 Flex, Pika's post-trained version of MiniMax H3, and H3 Flex has had open weights on Hugging Face since 29 October. So the family underneath the demo is inspectable and, in H3's case, callable today. Enact is the part that is not. Here is what Pika actually published on 18 November, what the numbers mean, and which of them you should treat as a product claim rather than a measurement.

What Pika published, and what it deliberately left out

Pika's own blog post Research Preview: Pika Enact, dated 18 November 2026, showing the headline, the summary line about talking to your cast and shaping scenes as they unfold, and the three named interaction modes Live Staging, Live Actor Direction and Live Camera Control.

Two artefacts, both timestamped 18 November 2026. A blog post on pika.art titled "Research Preview: Pika Enact," filed under Research, and a post from the @pika_labs account at 18:53 UTC. Both say the same thing in the same order: this is an experiment, it mimics directing on set, and it is unavailable.

The post describes Enact as "an experimental live-streaming environment" rather than a model. That distinction is not marketing hedging — it is the accurate description. Enact is a serving and control system wrapped around a distilled generator: one part turns what you do with a mouse or your voice into conditioning signals, another part emits video and audio in sub-second chunks while carrying scene state forward. There is no single "Enact model" with a version number and a context window. There is a video model, a script model, and a lot of plumbing between them and you.

What the post does not include, checked on 19 November:

• No endpoint, model ID or API reference. Pika's documentation sits behind a login, and nothing on the public site exposes Enact as a callable model.

• No price. Not a per-second rate, not a credit cost, not an enterprise tier. The only commercial detail is the contact address.

• No waitlist or early-access form. Compare that with the usual research-preview playbook, which almost always collects emails.

• No resolution figure for Live Staging or Live Actor Direction. Only the camera mode gets one, and it is the number discussed below.

• No independent evaluation. Every figure in the post is Pika's own, measured on Pika's hardware, with no harness or prompt set published.

Treat the absence of a waitlist as the strongest signal in the whole announcement. A company that intends to let outsiders in soon tends to build a door.

Three modes, three very different compute bills

The post separates Enact into three interactions, and they are not three views of the same feature. Each has its own hardware profile, its own speed multiplier and its own training pipeline, which is a good indication that the three were built independently and stitched together late.

Live Staging is the mouse-dragging mode. You grab an actor or an object inside a playing video and move it, and poses, lighting and shadows follow. Pika reports it generating "1.8× faster than it plays" on a single server, with the picture responding in "under 0.4 seconds on H100" including decode. It injects three frame-aligned signals — 24 fps mouse states, a spatial grab heatmap, and the untouched source video — through zero-initialized modules, which is the standard trick for bolting a new control channel onto a frozen generator without wrecking what it already does.

Live Actor Direction is the one the announcement leads with, and it is the most complex of the three. You type or speak a note, the actor acknowledges it in character and plays with it, and lines are "logged verbatim" so later notes can reference earlier ones. Then you say Action and the rehearsal collapses into "one clean take, shot fresh from the first frame." Under the hood this is two models in a loop: a script model that turns your spoken note into structured beats via tool calls, and a real-time video model that acts them. Pika puts generation at "1.75× faster than they play."

Live Camera Control is the mode with the least flattering and therefore most useful numbers. You orbit, pan or dolly a virtual camera during generation, and Pika says it needs only an appearance image plus a lightweight 3D motion proxy — an untextured Blender viewport will do. It runs on an "8×NVIDIA B300 node" at "640×480 @ 24 fps," rendering initial frames in 0.51 s and then "0.473 s per 0.708 s chunk, or 1.50 x real time."

Read those three multipliers in sequence: 1.8×, 1.75×, 1.50×. Those are not headroom figures chosen for effect. They are the margins by which a streaming system stays ahead of the clock, and the camera mode has the thinnest one because it is also the one holding an eight-GPU node at a quarter of the frame size a consumer would expect.

Why "faster than it plays" is the whole trick

Video models do not normally stream. They denoise a whole clip, then hand it over finished. Interactive direction is impossible under that model, because the scene has already been decided before you see it. Pika's fix is architectural rather than incremental, and the post is unusually specific about it:

• Chunking — output is emitted as causal chunks of "0.7 s standard, 0.17 s low-latency." The 0.17 s figure is what buys the sub-0.4-second response in staging; a bigger chunk means a longer wait before your drag is visible.

• Sliding KV cache — the context retains the prompt, the source video, the first chunk and the four most recent chunks. Older chunks fall out, so cost per chunk stays flat instead of growing with session length.

• Re-based positional embeddings — Pika's phrasing is "infinite sessions at constant cost." Same idea, different mechanism: the model never runs out of position indices because the reference frame keeps moving.

• Distillation — the sampler drops "from twenty steps to just a few," using "self-forcing distribution matching distillation (DMD)" with a trainable critic and a full-clip teacher. A twenty-step model cannot hit 24 fps; a three-or-four-step one can.

• A drift guard — the opening anchor frame can pull an idle scene back toward its start, and a "Real-Time Director" silently injects periodic hold beats. This exists because a system this autoregressive will wander if left alone, and the fix is to let it be nudged rather than to retrain it.

None of that is exotic in isolation. What is unusual is that all of it is pointed at the same constraint — keep generation ahead of playback — rather than at output quality. Which is exactly why the sample clips, however good, are not the interesting part of this announcement.

The number Pika didn't put in the headline

A scoreboard for Pika Enact listing six rows: what it is, an experimental live-streaming environment; base model, Pika H3 Flex; live staging, 1.8x real time with sub-0.4-second response on H100; actor direction, 1.75x real time with a script model and a video model in a loop; camera control, 640x480 at 24 fps on eight B300s at 1.50x real time; available today, no, research preview with an enterprise contact only.

The camera-mode line is 640×480 at 24 fps on eight B300 GPUs. If Enact were a product launch, that number would be buried. It is the single most informative figure in the post, because it is the honest exchange rate between interactivity and resolution: to stay 1.5× ahead of playback while you steer a camera, the system renders a quarter-VGA stream on a node that costs more than most studios' entire render budget.

Does that make the demo fake? No. It makes it a demonstration of headroom, and headroom on frontier hardware is how every interactive media system has shipped its first version. The relevant question for a reader is not whether 640×480 is good enough. It is what the ratio looks like on hardware you can rent, and Pika does not say. The staging mode's H100 figure is the closest thing to an answer — one GPU, under 0.4 seconds — and staging is a far simpler control problem than camera work.

The other unreported dimension is how long a session actually holds together. A sliding cache with four recent chunks plus an anchor frame is a design for staying coherent, not a guarantee of it. Nothing in the post gives a session length, a drift measurement over time, or an example of a ten-minute take. Until someone outside Pika runs one, "infinite sessions" is an architecture, not a result.

What you can run this week

Enact, nothing. H3 Flex, yes — the weights went up on 29 October as Pika-Labs/Pika-H3-Flex alongside a Turbo LoRA, and the main repository has logged more than 166,000 downloads according to the Hugging Face API as of 19 November. That is a genuinely unusual situation: the base generator for an unreleased interactive demo is downloadable, and the parts Pika kept back are the audio-stem separation and the accelerated serving stack.

The OrcaRouter model page for MiniMax H3, showing the identifier minimax/minimax-h3, unified text, image, video and audio inputs feeding video output, a video-generation endpoint, and per-second pricing of 0.08 dollars per second at 768P.

If you want the un-distilled ancestor rather than the Pika post-train, MiniMax H3 is the model Enact's whole stack descends from — an omni-modal generator with native stereo audio that reads text, image, video and audio references as one context. It is served through OrcaRouter on a per-second basis, $0.08 per second at 768P and $0.13 at 2K, billed at provider list price with no markup added, so a vendor price change is live here the same day it is announced. That is a different product from Enact and a different checkpoint from H3 Flex; it is simply the cheapest way to find out whether H3-family output suits your footage before committing to an eight-GPU mental model of what "real time" costs.

The routing layer earns its place in this particular story for a boring reason: an unproven, single-vendor, research-grade capability is exactly the thing you do not want to build a production path on. Failover across providers means a trial run of H3 does not become an outage when one endpoint is busy, and having every other model behind the same key and 200-plus models on one endpoint means the comparison you will inevitably want to make — H3 against Kling, against Seedance, against whatever shipped this week — does not require a second contract. None of that gets you Enact. It gets you the honest baseline to judge it against.

What would turn this from a demo into a decision

Four things, in the order they would change a reader's options:

• A door — a waitlist, a beta key, a credit price. Any one of these converts Enact from something to read about into something to plan around.

• A resolution above 640×480 for camera control, or a stated hardware requirement for staging at a usable frame size. The 1.8× margin on a single H100 implies a path there; Pika just has not published where it lands.

• A session-length result, ideally from someone who is not Pika. Drift over minutes is the whole ballgame for a directing tool, and it is the one thing a highlight reel cannot show you.

• A public prompt set or an independent latency harness. Pika's numbers are internally consistent and unusually detailed, which is a good sign, but "1.8× real time" measured by the team that built the distillation is a claim, not a benchmark.

Until at least one of those lands, the accurate description of Pika Enact is narrow and unglamorous: a working research system, published with real engineering detail, that its own maker says you cannot use. The engineering is worth reading — the causal chunking, the sliding cache and the distillation recipe are a plausible blueprint for how interactive video gets built by everyone else over the next year. The product does not exist yet, and no amount of 1.8× changes that.