betaFeedback

WorksComputer Science

CodeReel: Accelerating Code-to-Video Agents with Exact Frame Reuse and Blocking-Aware Scheduling

Abstract

Coding agents make videos by writing and refining programs in a build–inspect–edit loop. A finished film costs a median of $2.85 in model calls and 11 minutes, over a third of that time in builds that block the agent. We find that much of this time is avoidable, for two reasons. First, 37.5% of the frames of a session's later films were drawn before, many shifted in time or inside an edited scene. Second, half of the builds stop at a check, where the agent needs only the verdict, but which builds stop is unknown until the checks finish. We present CodeReel, a training-free execution layer behind agents' existing commands. Exact frame reuse keys each frame by its drawing commands, regardless of its position in time, and reuses each frame whose key recurs. Blocking-aware scheduling runs the checks first and starts the render alongside them, at idle priority, unless the session's recent builds make a pass unlikely. Scheduling spends CPU to answer sooner and reuse returns it; exact keys let later versions use frames rendered for a failed one as the agent thinks. We introduce EditLoop, a benchmark of replayable agent sessions whose films are checked against renders from scratch. On it, CodeReel cuts the agent's wait by 36.3% against Rebuild, a warm pipeline with parallel rendering, and by 57.9% against Sequential, today's step-by-step pipeline. On time-shifting edits its reuse renders 43.9%, close to the 43.0% whose pixels are new, while Manim-style caching renders 99.8%. With real agents, the median wait per build is 0.62x Rebuild's in Claude Code, on topics never used in development, and 0.67x in Codex CLI. The gain holds for five models and two frameworks.

Introduction

Coding agents such as Claude Code [3] and Codex CLI [51] produce videos by writing programs [9, 10, 32, 36, 37, 39]. To make an explainer film, the agent writes scene scripts, a narration timeline and assets, and then refines them in a loop (Figure 1a). In each round it builds the program, inspects the errors or the film, and revises the sources. Some revisions fix its own defects, such as text over subjects or captions out of sync with the speech [9, 36, 37]; others answer its user’s change requests. Each build is a tool call. Some agents use current pipelines run theirs [9, 32]: it synthesizes the narration’s voice, lays out the timeline, checks the whole film and, if the checks pass, renders every frame. It returns a verdict, pass or fail, with the film on a pass and the errors on a fail. In 123 recorded sessions of Claude Code, a finished film takes a median of 10 builds and costs $2.85 in model calls and 11 minutes. The builds take over a third of that time, each blocking the agent for a median of 25.5 s. We find that much of this wait is avoidable (Sec. 2). The first cause is redundancy: 37.5% of the frames of a session’s later films were drawn by an earlier version, yet they are rendered again. The second is a scheduling mismatch: 51.8% of builds stop at a check before any film is made. The agent waits for the verdict or the film depending on an outcome known

Code-to-video agents and CodeReel

Figure 1. Code-to-video agents and CodeReel. (a) The agent edits its program and calls a build, which returns errors if a check fails and a film otherwise. CodeReel adds blocking-aware scheduling at the checks (1) and exact frame reuse at the render (2). (b) One edit: frames of version 13 that version 11 drew at the same time (reused in place), at another time (reused, moved) or not at all (new), with the changes boxed; the bar gives each class’s share of its frames. (c) The build of version 13 under Rebuild and CodeReel.

only when the checks finish, yet the pipeline runs every build in one fixed order.

Challenges. Redundancy. An agent revises a film incrementally, so the frames an edit does not touch recur: 30.2% of later films’ frames at the same time in the previous film and 6.5% at another time (Figure 1b and Figure 3b). Three kinds of edit make recurring frames hard to identify before rendering. First, an edit to a file that scenes share changes only some frames of the scenes that read it. But a script draws a whole scene from one clock, with no call, node or layer boundary inside it. Caches keyed by an animation call as in Manim [63], a scene [17], a node or layer [1, 16, 62] or a file [11, 48] therefore redraw those scenes whole. Second, a narration edit moves every later scene. An incremental renderer such as kamishibai keys a frame by its index [29] and so misses frames that did not change. Third, many edits change little of a frame, such as a few words of a caption. Approximate reuse, as in training-free diffusion caches [28, 38, 45, 47] and in edit-time methods that recompute only the edited regions [34, 50, 72], reuses results whose inputs or features change little. But 32.6% of the changed frames keep an SSIM [65] above 0.99 to the frame they replace, so it can keep a stale frame that still shows the old words. Scheduling mismatch. A failing build should give every core to its checks, and a passing one should start its render at once. The checks and the render both process the whole film on the same cores, so a render alongside the checks slows the verdict, and one after them delays the film. The machine is idle while the agent thinks, but the version to build next is not yet written. Pipelines fix the order that completes the film [9, 32], schedulers for agents schedule around tool calls [30, 69, 71, 74], and test prioritization reorders the tests of a suite [56, 60]. None orders the work inside a build by what the agent is blocked on.

Where the time and the frames go on the real track

Figure 3. Where the time and the frames go on the real track. (a) Each session’s time. (b) Each later film’s frames: an earlier film drew them at the same time, at another time, or not at all.

Our approach. We present CodeReel, a training-free, model-agnostic execution layer behind the commands agents already call, built on two observations. First, video programs draw each frame from its time alone [58], so the commands a frame issues determine its pixels. Evaluating them costs 2.7 ms of CPU, against 81 ms per frame for a full render. Exact frame reuse therefore keys a frame by its drawing commands, regardless of its position in time, and reuses every frame whose key was rendered before. Second, a build call is synchronous, so the agent is blocked on the verdict until the checks return, on the film once they pass, and on nothing once the build has answered. Blocking-aware scheduling runs the checks first and in parallel, and decides from the session’s history and the machine’s cores whether to render alongside them. In the agent’s think time it works ahead, rendering a failed version’s frames, since a stored frame serves any later version that draws it. Neither technique changes the verdict or the film of a build.

On recorded sessions replayed on 32 cores, CodeReel cuts the agent’s wait by 36.3% against Rebuild, a pipeline with warm processes and workers sized to the machine (Figure 1c shows one build). Against Sequential, that pipeline run step by step as today’s agents run theirs [9, 32], the cut is 57.9%. CodeReel answers failing builds in 0.39× Rebuild’s time. Most of the reduction comes from scheduling, which spends CPU to answer sooner; reuse renders 34.9% fewer frames, returns that CPU and helps most where cores are scarce. Real agents wait less as well, with a median wait per build of 0.62× Rebuild’s in Claude Code, on topics never used in development, and 0.67× in Codex CLI. Of the reuse schemes without stale frames, CodeReel renders the fewest frames. On time-shifting edits it renders 43.9%, close to the 43.0% whose pixels are new, while Manim-style caching [63] renders 99.8%. On programs of another video framework, Remotion [59], the agent waits 0.51× as long under CodeReel as under Remotion’s own renderer (§ 4). We contribute:

  • EditLoop: a benchmark of replayable agent sessions, every delivered film checked against a render from scratch (§ 2).

  • Exact frame reuse: frames keyed by their drawing commands, shift-invariant, with cheaper tests first, returning the CPU that scheduling spends (§ 3.2).

  • Blocking-aware scheduling: a build ordered by what the agent is blocked on, spending CPU to answer sooner, with work ahead in its think time that exact keys let later versions keep (§ 3.3).

  • CodeReel: a general execution layer that existing coding agents use unmodified, across video frameworks (§ 3).

The EditLoop benchmark

Evaluating an execution layer for code-to-video agents needs a record of what agents did, in a form any system can replay. Code-to-video benchmarks grade the film [9, 10], a video-editing benchmark adds the agent’s runtime and cost [20], and traces of coding agents record tool durations or turn lengths to benchmark LLM serving [33, 53, 77]. None keeps each program version with the tool calls that built it. EditLoop keeps both, so every system can replay the same calls in order, and it checks every delivered film against a render from scratch. We release the sessions with the replayer and its correctness gate.

Sessions and tracks

A session records one agent making one film: every version it committed, every tool call in order with its timing and outcome, the agent’s think time before each call, and the class of edit each build follows. The real track has 123 sessions of Claude Code [3] with Claude Opus 5.5 [4] making explainer films with cv.js, our Canvas 2D [66] runtime (Figure 2): 1,525 versions, 2,078 tool calls and 1,314 builds. Its films run 52 to 146 s between the 10th and 90th percentiles and are narrated in Chinese and English. Of its builds, 39.0% follow edits of new or removed files, 26.1% of narration lines, 12.6% of one scene’s script and 20.4% of shared scripts or data. It holds every session recorded over two weeks that built at least two versions. A scripted user issued every change request. Of the sessions, 60 are on topics that GPT-6.1 [52] wrote for EditLoop, each with three rounds of change requests that build on one another. The real track is split by topic: the 33 sessions on topics used to tune any parameter form the development split, and the other 90, on 72 topics that include all of GPT-6.1’s, the test split. Timing replays one session from each of 70 topics, drawn with a fixed seed. The reuse study takes the 355 pairs of adjacent delivered versions of 88 test-split sessions. The model track has 20 sessions of Claude Sonnet 5.5 and Haiku 5.5 [4] on 10 topics. The Remotion track brings a second framework, Remotion [59], with synthetic edits whose classes and think times follow the real track’s: 150 versions in 6 sessions.

Figure 2. Films of EditLoop and their edits. Top: eight real-track films, by topic (6 to 22 builds each). Bottom: eight edits, the old frame above the new one and what changed between them; similarity-based reuse keeps the old frame (SSIM above 0.98), while CodeReel renders the new one.

Protocol and metrics

Replay is closed-loop [61]: a system executes a session’s recorded calls in order, each after the previous one has answered, either at once or after the recorded think time. Caches start cold in every session.

Correctness gate. EditLoop requires the from-scratch consistency of incremental computation [22], and reports a system’s times only if every build keeps it. A build must return the verdict of a build from scratch and no error that the latter does not report, and every frame of every delivered film must equal a render of that version from scratch (supplementary material).

Metrics. Renderers are compared by render time [29], which misses what blocks the agent. We therefore measure the wait, from a build’s call until the build answers the agent: at the verdict when it fails, after the film when it passes.

Where the time goes

The real track yields three findings (Figure 3).

F1: builds take over a third of a session. In the median session, tool calls take 37.7% of the time and builds alone 37.0%. Builds take a median of 25.5 s and think times 8.0 s.

F2: half of the builds fail. 51.8% of builds stop at a check, for text over subjects, clipped text, captions out of sync or lint errors. In these builds the agent waits only for the verdict; in the others, the render waits for the checks.

F3: later films repeat 37.5% of their frames, unevenly. Over the 291 films after a session’s first in the timed test sessions, 37.5% of the frames repeat, command for command, a frame an earlier film drew. Of all frames, 30.2% repeat at the same time in the previous film, 6.5% at another time in it, and 0.8% only in an older film. Of these films, 37.8% are over nine tenths new and 11.7% under a tenth.

Exact reuse removes what F3 repeats; blocking-aware scheduling puts F2’s checks first, overlaps the render with them unless a pass is unlikely, and works in F1’s think time.

Method

CodeReel reduces the agent’s wait in two complementary ways, one per observation of § 1 (Figure 4): exact reuse across versions removes work and frees CPU, and blocking-aware scheduling spends it on what the agent waits for.

CodeReel blocking-aware scheduling and exact frame reuse

Figure 4. CodeReel. The agent’s synchronous build call enters the scheduler (Alg. 1), which runs the verdict’s operations first, the film’s alongside or after them, and a failed version’s frames while the agent thinks. Every render passes the reuse cascade, cheapest test first: static impact sends the frames an edit can reach to the frame key, values read keeps the keys of the others, and only frames with new keys or no key are rendered, the keyed ones into the frame store. Costs are CPU time per frame, including sound and encoding for the render, and per build for static impact.

Model

Video programs. A video program PP defines a film FPF_P, one frame FP(t)F_P(t) at each time tt of a frame grid. It draws each frame onto a canvas, or lays it out as a page, from tt, its source files and the assets they load. CodeReel relies on the frame contract Remotion states for its programs [58]: FP(t)F_P(t) depends on nothing else, not on randomness, earlier frames or wall-clock time. The runtime and the checks catch programs that break it (supplementary material).

Builds. As build systems model a build [48], a build of PP is a directed acyclic graph GPG_P of CPU operations, each serving a consumer. The verdict V needs each changed narration line voiced, the timeline laid out, the film checked at sampled times and the sources linted. The film F needs every frame and the sound rendered, the sound’s levels checked and each segment encoded. A later version is the consumer of frames rendered ahead. The verdict oP∈{pass,fail}o_P \in\{\text{pass},\text{fail}\} is known at TVT_V, when its checks finish. A failing build answers with its errors at TVT_V. A passing one answers at TF≥TVT_F \ge T_V, once its film and the checks that need the film have finished, with the film or those checks’ errors. With times measured from the call and [⋅][\cdot] the indicator, the agent waits

WP=TV[oP=fail]+TF[oP=pass].(1)W_P = T_V [o_P = \text{fail}] + T_F [o_P = \text{pass}]. \tag*{(1)}

Problem. A session builds versions P1,…,PnP_1,\ldots,P_n, each given what the builds before it computed. The goal is to minimize the expected total wait E[∑iWPi]\mathbb{E}[\sum_i W_{P_i}] over the outcomes, each unknown when its build starts. Exactness asks for the verdict of a build of PiP_i from scratch and, when it passes, for its film, frame by frame. Capacity asks that the operations running at once fit the machine’s cores and memory, which other agents may share (supplementary material). CodeReel removes from GPiG_{P_i} the operations already computed, shortening TVT_V and TFT_F (§ 3.2), and orders the rest by consumer (§ 3.3).

Exact reuse across versions

Reuse must decide, without rendering a frame, whether its pixels can differ from those of a frame rendered before. Following the first observation, CodeReel keys each frame by its drawing commands. Each part that draws the frame at time tt of PP, a scene’s drawing or an overlay such as subtitles, records the commands it issues through the runtime’s supported interfaces, with their arguments and drawing state; images and fonts enter by their bytes. The frame’s key is

κP(t)=h(σP(t),ν(a1),…,ν(am)),(2)\kappa_P(t)=h\left(\sigma_P(t),\nu(a_1),\ldots,\nu(a_m)\right), \tag*{(2)}

where σP(t)\sigma_P(t) holds the frame’s structural inputs, such as its size, fonts and the order of its parts, a1,…,ama_1,\ldots,a_m are the commands in drawing order, ν\nu is their normalization to the rasterizer and hh is a hash. Like the keys of build systems [48] and compositors [16], a key is sound if equal keys imply equal outputs, so every reused output is exact, and tight if equal outputs get equal keys, so no output is computed twice.

Property 1 (Soundness). For a frame drawn under the frame contract through supported interfaces, on one renderer configuration whose rasterizer draws a frame from its commands alone, with vv merging no two commands that the rasterizer draws differently and hh collision-free: if its key equals that of a frame rendered before, its pixels equal that frame’s.

A frame drawn through an unsupported interface gets no key and is rendered every time. 98.6% of the frames are keyed, and Sec. 4.4 reports the audit of every key.

Normalizing keys to the rasterizer. If a key changes while the pixels do not, the frame is not rendered needlessly; if it stays while they change, a stale frame is shown. The normalization ν\nu therefore rewrites only the commands whose rasterization we characterized.

For example, the rasterizer places text at a baseline snapped to whole device pixels, so such text enters the key with the snapped baseline. Every other number enters a key exactly.

Following frames through time. A narration edit changes one line’s duration and moves every later scene, so a cache looked up by time or frame index [29] misses every frame of a moved scene, although none changed. The video framework Fourier follows whole layers that move [17]. κ\kappa is shift-invariant, since it holds no absolute time: scenes draw from their local time and start on whole frames. A scene that the next version P′P' moves Δ\Delta frames later, its other inputs unchanged, therefore issues at t+Δt+\Delta the commands it issued at tt, and κP′(t+Δ)=κP(t)\kappa_{P'}(t+\Delta)=\kappa_P(t) for a frame whose other parts do the same.

The cascade. Evaluating κ\kappa for every frame would still cost a pass over the program, while the frames an edit cannot reach need no new key, so cheaper tests come first (Figure 4, right). Static impact works like a build system’s file dependencies [11, 48]: a scene’s script draws only inside the scene’s time window, so the frames inside the windows Ω\Omega that the changed scripts reach go to evaluation. Values read tracks dependencies as they are used, as incremental computation does [23]: the runtime records hashes of the values each frame read, such as the timeline, the style or an asset entry. A frame outside Ω\Omega keeps its key when they are unchanged, so editing one style entry sends to evaluation only the frames that read it. Such a frame issues the same commands as before, so its kept key equals κP(t)\kappa_P(t) (Property S1 of the supplementary material). For the remaining frames, evaluating κ\kappa runs the drawing code and records its commands, as browsers and UI toolkits keep display lists [15, 62], without capturing the frame.

What is reused. A frame store holds the rendered frames by key, per renderer configuration: a build takes from it every frame whose key it holds and renders the rest, each missing key once. The film’s encoded segments, which hold pictures only, are reused by their frames’ keys, and the checks’ results wherever static impact and values read keep a key.

Another framework. The key and the store carry over to any runtime that exposes what each frame draws and keeps the frame contract: in Remotion [59] this is the laid-out page, its elements with their computed styles and resources by content, and frames with new keys go to its own renderer.

Algorithm 1 One build of version $P$ on $c$ cores (Sec. 3.3).

Input: $P$, $\hat{p}$, $\theta_c$; work ahead $A$
Output: the answer to the agent
1: stop $A$; $H \leftarrow \varnothing$
2: $e \leftarrow [\hat{p} > \theta_c]$ ▷ early render
3: $\Lambda \leftarrow \operatorname{Layout}(\operatorname{Voice}(P))$
4: if $e$ then $H \leftarrow \operatorname{Render}(P,\Lambda,\operatorname{idle})$ ▷ asynchronous
5: $(o,E) \leftarrow \operatorname{Check}(P,\Lambda) \parallel \operatorname{Lint}(P)$
6: if $o = \operatorname{fail}$ then
7: answer $(o,E)$; cancel $H$
8: $A \leftarrow \operatorname{Render}(P,\Lambda,\operatorname{background})$ ▷ work ahead
9: else
10: if $e$ then promote $H$ else $H \leftarrow \operatorname{Render}(P,\Lambda,\operatorname{normal})$
11: wait for $H$; answer $F_P$, or the errors of $\operatorname{FilmCheck}(F_P)$

Blocking-aware scheduling

The usual pipeline runs every operation at one priority, in the order that completes the film [9, 32]. Following the second observation, CodeReel schedules each operation by the consumer that waits for its output: the operations the verdict needs run first, those only the film needs run alongside them when that pays off, and work no one waits for yet runs in the agent’s think time. Each operation also takes its consumer’s share of the processor. The verdict’s operations (Alg. 1, Alg. 1), and the film’s once the agent waits for it (Alg. 1), run at normal priority. A render started early (Alg. 1) runs at idle priority, which gets only the processor time the others leave. Work ahead AA runs in the background, at low priority, until the next build starts (Alg. 1) or blocking work needs memory, and keeps the frames it stored. In Alg. 1, Voice, Layout, Check and Lint are the verdict’s operations of Sec. 3.1, and Λ\Lambda is the layout the checks and the render read. The operator ∥\parallel runs two operations at once, oo and EE are the verdict and the errors, and FilmCheck runs the checks that need the film FPF_P. Render(P,Λ,π)(P,\Lambda,\pi) starts rendering PP in priority class π\pi and returns its handle HH.

Within a build: the verdict first. On half of the builds the agent waits only for the verdict, whose checks cover the whole film. CodeReel runs the checks first and in parallel, with the lint alongside them. Its fast checks leave out what a verdict does not need: the checks that read a frame’s texts and images sample frames as a key is evaluated, by running the drawing code without capturing pixels, and they map drawn objects to source lines only after the verdict. With few cores, a build also fails fast, as in test prioritization [56, 60]: the checks that seldom fail run only once the others found no error, and the build answers at its first errors.

Within a build: the render as a bet. Starting the render alongside the checks is a bet on the outcome, like the sandboxes that agent serving systems prewarm [74]. It saves render time when the version passes and slows the checks in either case, so it pays when the expected saving exceeds the delay. At idle priority, the render slows the checks by a fraction dd and keeps a share of its speed, and the bet pays when the version passes with probability above α=d/(1+d)\alpha= d/(1+d) (supplementary material). Idle priority keeps the bet cheap, with a measured θc\theta_c of 0.25 on 8 cores and 0.21 on 32. Algorithm 1 takes the bet when p^>θc\hat{p} > \theta_c, where p^\hat{p} is the pass rate of the session’s last five builds of the same kind, with the development split’s as prior. A session’s first build, which rarely passes, thus renders after its verdict, and later builds render early (Figure 1c), 88.9% of builds on 32 cores and 87.6% on 8.

Across the agent’s think time. The machine would be idle while the agent reads a failed build’s errors; serving systems use such windows too [68]. The build therefore answers at its verdict, cancels any render started early (Alg. 1) and keeps the frames it stored. It then renders the rest of the failed version’s frames into the frame store as work ahead (Alg. 1), until the next build stops it. By Property 1, a stored frame is exact for any later version that draws it.

Experiments

Experimental setup

Frameworks and hardware. Every system renders the same programs at 1080p and 30 frames per second: cv.js programs, written for our Canvas 2D runtime and run in headless Chromium, and Remotion [59] programs, written in React. The machines are 32, 8 or 4 of one server’s cores, with 2 GB of memory per core. 32 cores are abundant, since a render starts fewer workers than there are cores; 8 are constrained, since a render can use more workers than cores; and 4 are saturated, since frame capture alone fills them. Every system renders on the CPU (supplementary material).

Baselines. For the wait, Rebuild is CodeReel without exact reuse and blocking-aware scheduling: one priority for every operation, the checks in a single browser page with the lint after them, no fast checks or failing fast, and the render after the checks. It keeps every other mechanism, such as warm browser pages, a resident voice process and workers sized to the machine. Sequential runs a build’s steps one after another on the same runtime, with cold browser pages, a cold voice process and eight render workers, as code-to-video agents run theirs [9, 32]. For reuse, we implement on the same films the schemes that tools and caches use. Scene windows re-render the time windows of the scenes whose files changed, and read sets re-render the frames whose files or read values changed. Kashmibai-style fingerprints [29] are typical, over a part’s file and timing, or careful, adding every shared script and the whole timeline. Manim-style per-call caching keys each scene whole, by its files and the values it reads, as Manim keys each animation call [63]. Complete keys reuse whole scenes or narration lines when all their frames’ keys recur. The similarity rule reuses a frame as approximate caches do [2, 38], on frame thumbnails.

Protocol. EditLoop’s test split is replayed as in Sec. 2, each session once per system, back to back on the same cores in alternating order. Replays run without think time, which only work ahead uses (Sec. 4.3). The primary estimate is the ratio of total waits over builds bb, ∑bWb/∑bWbR\sum_b W_b/\sum_b W_b^R, with WbRW_b^R the wait under Rebuild; 95% intervals come from 2,000 bootstrap resamples of topics [14]. We registered the protocol before any formal run, with three claims: no stale frame, a ratio below one on 8 and on 32 cores (Holm-corrected [24], one-sided 2.5%), and a shorter median wait per build for real agents.

Comparison with existing systems

Table 1 shows that CodeReel answers soonest on every workload. Each external system runs as shipped, on the programs written for it, with as many render workers as CodeReel. On EditLoop’s real track, relative to Sequential, the agent waits 0.42× as long under CodeReel, which uses less CPU, and 0.66×0.66\times as long under Rebuild, which uses more. Figure 5 gives the wait in seconds. CodeReel answers 95.4% of the builds sooner than Rebuild does. On the Remotion track, replayed on 8 cores, the agent waits 0.51×0.51\times as long under CodeReel as under Remotion’s own renderer [59], with 5.6% of the frames rendered. Under HyperFrames [26], an HTML video framework for agents that renders each version from scratch, the agent waits 0.96×0.96\times as long on the programs ported to it. On kamishibai’s own benchmark [29], five edits of its reel after a first render, CodeReel takes 0.82×0.82\times the time of kamishibai run incrementally, which renders the frames whose fingerprint changed.

SystemWaitCPUMemoryFramesExact
EditLoop’s real track (Canvas 2D, 32 cores; 70 topics)
Sequential [9, 32]23.2 s143 s4.3 GB1,399363/363
Rebuild0.661.171.831.00363/363
CodeReel0.420.951.700.65363/363
EditLoop’s Remotion track (React, 8 cores; synthetic edits)
Remotion renderer [59]11.9 s91 s2.2 GB1,003–
HyperFrames [26]0.960.590.931.00–
CodeReel0.510.200.880.06150/150
kamishibai’s edit benchmark [29] (React, 8 cores)
Remotion renderer [59]25.4 s104 s2.3 GB2,580–
HyperFrames [26]1.521.500.871.00–
kamishibai, full [29]1.421.140.581.00–
kamishibai, incremental [29]0.800.481.430.2515/15
CodeReel0.660.510.760.2515/15

Table 1. CodeReel against existing systems by workload. A block’s first row gives the mean wait, CPU-seconds and frames per build and the peak memory; the other rows are relative to it. Exact counts the delivered films equal to a render from scratch (–: an external renderer, which renders each version from scratch).

Figure 5. The agent’s wait per build on 32 cores, as the share of builds answered within a time, over the 339 builds that end at the verdict and the 363 that deliver a film; dots, the medians (s).

Wait across machines and agents

Under CodeReel the agent waits less than under Rebuild on every machine, for every model and in both harnesses, Claude Code and Codex CLI, on failing and on delivering builds (Failed and Film in Table 2).

SettingWaitFailedFilmFramesCPU
CodeReel by machine
32 cores0.640.390.710.650.81
32 cores, think time0.590.410.650.490.92
8 cores0.670.430.710.660.76
8 cores, think time0.600.430.630.530.86
4 cores0.750.460.790.630.72
Rebuild with one mechanism
32 cores, reuse0.940.970.940.660.81
32 cores, verdict first0.690.490.751.001.12
32 cores, fast checks0.820.580.891.000.98
8 cores, reuse0.860.960.840.660.82
8 cores, verdict first0.860.600.901.001.05
8 cores, fast checks0.880.570.941.000.96
CodeReel without one mechanism, on 32 cores
every mechanism0.620.380.690.650.77
without reuse0.650.380.731.000.98
without verdict first0.760.560.820.650.77
without fast checks0.650.470.690.640.87
never rendering early0.660.370.730.650.74

Table 2. Wait, frames and CPU relative to Rebuild. CodeReel by machine, Rebuild with one mechanism on 32 and 8 cores, and CodeReel without one on 32 cores, in a second replay whose first row is the full system.

The registered tests on 32 and 8 cores replay the 70 timed topics, and the run on 4 cores replays 20 of them. On 32 cores, the main setting, the agent waits 0.64×0.64\times as long (95% CI 0.61–0.66): 0.39×0.39\times on failing builds and 0.71×0.71\times on builds that deliver a film. CodeReel

renders 34.9% fewer frames and, over all builds, returns the verdict in 0.35×0.35\times the time. On 8 cores the agent waits 0.67×0.67\times as long (CI 0.64–0.69), and on 4 cores 0.75×0.75\times (CI 0.70–0.80). Both registered tests pass, and every build passes the correctness gate. On the 24 live sessions of Sec. 4.5 on topics never used in development, the agent waits 0.60×0.60\times as long on 32 cores and 0.66×0.66\times on 8.

With the other models and harnesses, Claude, Sonnet and Haiku from the model track, DeepSeek V4 [12] in Claude Code and GPT-6.1 in Codex CLI, the agent waits 0.54–0.62× as long on 32 cores, each interval below one.

Across sessions. The agent waits less in sessions that render fewer frames again (Figure 6a): on the least-squares line, wait = 0.38 + 0.37 · frames, both relative to Rebuild. § 4.6 separates what reuse and scheduling each contribute.

The gain across sessions and edits

Figure 6. The gain across sessions and edits. (a) Wait against frames rendered, both relative to Rebuild, per session (gray) and per agent (colored; †: each agent’s first session on nine topics); solid, the per-session fit; dashed, y=xy=x. (b) Frames rendered against frames with new pixels, per adjacent pair, CodeReel and Manim-style caching [63]; points below the dashed line, pixel truth, reuse stale frames.

Think time and work ahead. Replayed with the recorded think time, work ahead shortens the wait further, to 0.60×0.60\times Rebuild’s on 8 cores and 0.59×0.59\times on 32 (Table 2). On 8 cores that is 0.90×0.90\times the wait without work ahead.

Shared machines. A machine is one budget for all its agents: CodeReel keeps a ledger of its cores and memory and sizes each render to what is left, blocking work first, so every agent gets its films where uncoordinated renders outgrow the machine (supplementary material).

Exactness and tightness of reuse

Over the 1,023,902 frames of the reuse study’s 355 pairs, CodeReel reuses no frame whose pixels changed and renders 63.2% of the frames, 1.05×\times those whose pixels are new. Every other scheme renders more or reuses stale frames (Table 3). The similarity rule of Table 3 leaves 7.0% of all frames stale. These frames miss the agent’s edit (Figure 2, bottom) at a median SSIM of 0.999 to the correct frame (supplementary material). No frame CodeReel reuses is stale, here or in 2,000 random edits, and an audit of every key against a lossless capture of its frame finds no key that stands for two pictures (supplementary material).

MethodExactAdjacent versionsTime-shifting edits
Scene windows×\times90.3%100.0%
Read sets×\times83.8%53.2%
Kamishibai-style, typical [29]×\times63.5%54.0%
Kamishibai-style, careful×\times89.0%99.8%
Manim-style [63]×\times88.0%99.8%
Similarity, threshold 0.1 [38]×\times59.7%–
Per scene, complete keys✓\checkmark80.2%81.1%
Per line, complete keys✓\checkmark71.1%64.5%
CodeReel✓\checkmark63.2%43.9%
Pixel truth✓\checkmark60.2%43.0%

Table 3. Frames rendered by each reuse scheme on the test split’s adjacent versions and on time-shifting narration edits (cv.js). Exact: no stale frame; similarity: a frame reused when its gray thumbnail differs from the previous version’s by less than 0.1 on average; pixel truth: the frames whose pixels are new.

The cost of each edit. On 85.6% of pairs, CodeReel stays within 5 points of the share of frames whose pixels are new (Figure 6b), while Manim-style caching renders whole scenes.

Time-shifting edits. In 32 narration edits to four cv.js films (Table 3, right), CodeReel renders 43.9% of their frames, against 43.0% whose pixels are new, and reuses no stale frame. Read sets reuse 7,228 stale frames. Remotion films give similar results (supplementary material).

Real agents in the loop

Under CodeReel, both agents wait less per build (Table 4). Each agent runs with the same model, topics and scripted user under Rebuild and under CodeReel. Claude Code runs with Claude Opus 5.5 in 26 pairs of sessions on 16 topics, six of them from Code2Video’s benchmark [9]; Codex CLI runs with GPT-6.1 on those six topics, twice each. Each pair’s ratio compares the two sessions’ median wait per build (Wait) and per delivering build (Film), total wait (Total), builds and wall-clock time (Time). Faults is the difference in the number of defects that Claude Opus 5.5 [4], blind to the system, lists in the final film. On the 14 untouched pairs, on topics never used in development, the registered median wait per build drops to 0.62×0.62\times (CI 0.43–0.82) and the total wait drops to 0.69×0.69\times. Through Codex CLI, wait per build drops to 0.67×0.67\times (CI 0.52–0.79) and the total to 0.68×0.68\times. A session ends sooner as well (Time). The films’ faults do not differ, and every final film CodeReel delivered equals a render from scratch.

AgentPairsWaitFilmTotalBuildsTimeFaults
Claude Code, untouched140.620.760.690.930.83−0.29
Claude Code, all260.590.730.701.010.84−0.42
Codex CLI120.670.580.680.980.83−0.58

Table 4. Real agents on 8 cores, CodeReel relative to Rebuild (geometric means over pairs; Faults: CodeReel minus Rebuild, every 95% interval including zero).

Ablation study

As Table 2 shows, most of the reduction on 32 cores comes from scheduling, which spends CPU to answer sooner, while reuse cuts frames, returns that CPU and helps most where cores are scarce. Added alone to Rebuild, reuse renders 34.3% fewer frames and shortens the wait to 0.94×0.94\times on 32 cores but 0.86×0.86\times on 8, where rendering fills the machine. The verdict first alone, with all the checks in parallel and the render alongside them, shortens it to 0.69×0.69\times on 32 cores with 1.12×1.12\times the CPU. Removing any one mechanism from CodeReel lengthens the wait, most of all the verdict first (to 1.22×1.22\times). Without reuse the CPU rises to 1.27×1.27\times.

Related work

Code-to-video agents. Agents write Manim, web or slide programs refined in a render loop [9, 32, 36, 37, 78], check animations in that loop [42, 46], drive simulators [5] or mix programs with generative models [39]. None reuses more than its framework’s per-call cache, and none targets the agent’s wait.

Reuse. Training-free caches [38, 40, 47], edit-time methods [34, 41, 50], render caches [49, 64] and video networks that skip unchanged regions [13, 21, 55] approximate the full computation. Production tools, browsers and UI frameworks cache or skip by node, layer, object or component [1, 15, 16, 27, 57, 62]. Closest to us, Manim keys animation calls by their inputs [63], kamishibai fingerprints a frame’s page at the same index [29], HyperFrames repeats frames its timeline predicts static [26], and Fourier fingerprints scenes and layers, also after a layer moves in time [17]. Browsers and UI toolkits keep drawing commands as display lists within one page’s lifetime [15, 62]; CodeReel keys whole frames by their evaluated commands, so frames of imperative code with one clock are found in any version at any time (Table 3). Like build systems and their content-addressed caches [6, 11, 23, 48], it is consistent with a build from scratch, but it keys what a program draws instead of what it reads.

Scheduling around agents. Test prioritization runs likely failures first [56, 60], and agent systems schedule around tool calls [30, 43, 68, 69, 71, 74, 76]. CodeReel schedules within a build by what the agent is blocked on, and the frames it renders ahead need no rollback.

Limitations and conclusion

CodeReel shortens a code-to-video agent’s wait by exact frame reuse, which removes repeated work, and blocking-aware scheduling, which spends the CPU it frees on what the agent waits for; neither changes the film a build delivers. On EditLoop, the wait falls by 36.3% against Rebuild and 57.9% against Sequential, and the gain holds across models, harnesses and frameworks.

Our scope is 2D video programs whose drawing a runtime can record. Frames of 3D scenes are rendered exactly but never reused, footage from generative models lies outside the scope, and an edit that changes most frames gains mostly from scheduling. Exact reuse for 3D and GPU rendering, and agents that plan their edits around what can be reused, are directions for future research.

LLM usage statement

LLM coding agents are the subject of this study: EditLoop records their sessions, and Sec. 4.5 runs them live. GPT-6.1 wrote sixty of EditLoop’s topics, and Claude Opus 5.5 scored the real agents’ films blind to the system. A coding agent helped implement the system and the experiment scripts, ran experiments under the authors’ direction and drafted parts of the text from the authors’ notes. The authors checked every result and reference, revised all text and take full responsibility for the content; no LLM is an author.

EditLoop in detail

A session records one agent making one film: every version it committed, every tool call in order with its timing and outcome, the agent’s think time before each call, and the class of edit each build follows. The real track has 123 sessions of Claude Code [3] with Claude Opus 5.5 [4] making explainer films with cv.js, our Canvas 2D [66] runtime (Figure 2). These sessions hold 1,525 versions, 2,078 tool calls and 1,314 builds. Their films last 52 to 146 s between the 10th and 90th percentiles and are narrated in Chinese and English. Of the track’s builds, 39.0% follow edits that add or remove files, 26.1% follow edits of narration lines, 12.6% follow edits of one scene’s script and 20.4% follow edits of shared scripts or data. The track holds every session recorded over two weeks that built at least two versions. A scripted user issued every change request. Of these sessions, 60 are on held-out topics, which GPT-6.1 [52] wrote for EditLoop. Each held-out topic has three rounds of change requests that build on one another. The model track has 20 sessions of Claude Sonnet 5.5 and Haiku 5.5 [4] on 10 test topics. The Remotion track brings a second framework, Remotion [59], with synthetic edits. For each of two films we wrote and each of three random seeds, a generator applies 24 edits in turn. The generator draws each edit’s class and the think time before each build from those of the real track. This gives 150 versions in 6 sessions. The real track is split by topic. The 33 sessions on topics used to tune any parameter form the development split. The other 90 sessions, on 72 topics that include all of GPT-6.1’s, form the test split. § 4 reports results on the test split. The timed replays take one session from each of 70 topics, drawn with a fixed seed. The reuse study takes the 355 pairs of adjacent delivered versions of 88 test-split sessions.

Format. A session directory holds four entries. session.json gives the track, framework, topic, date, narration language, film length, the agent’s model and harness, the machine profile, the framework’s commit, counts, edit classes, the voice pool and what was scrubbed. manifest.jsonl gives each version’s files by content hash. calls.jsonl gives, per call, the tool, the agent’s arguments with the project path abstracted, the version the call saw, the call’s start, recorded duration and exit, a build’s verdict time and edit class, and the think time before the call. objects/ holds the file contents by hash. A call’s version is the version committed within 2 s of the call’s start or, if there is none, the newest version before the call.

Held-out topics. GPT-6.1 wrote the held-out topics of the 60 sessions in five kinds (concepts, data, systems, teaching, products) and two languages. Each topic has three rounds of stacked change requests: a local change, a global change, and a mixed change that takes something back.

Replay is closed-loop [61]. A system executes a session’s calls in order, each call after the previous one has answered, either at once or after the recorded think time. The system’s caches start cold and persist across versions but not across sessions.

Correctness gate. Approximate reuse is judged by image similarity [38]. EditLoop instead requires the answers of a build from scratch before any time counts, which is the from-scratch consistency of incremental computation [22]. A build must pass or fail as the build from scratch does, and it must report no error that the build from scratch does not report. Every captured frame of every delivered film must equal the frame that a render of that version from scratch captures. The sound must match within the tolerances given below.

Metrics. Renderers are compared by render time [29], which misses what blocks the agent. The wait therefore runs from a build’s call until the build answers the agent. A build that fails a check answers at the verdict, and a build that delivers answers after the film and its checks. We also report the time to verdict, frames rendered, CPU-seconds and peak memory.

The correctness gate in full. The reference for a verdict is a build from scratch. When both a system and this reference ran every check, the two verdicts must hold the same errors, each given by its check, element and time. Every frame that a system captures for a delivered film is compared with one reference shared by all systems, the frames of a render from scratch with no cache and no key. The encoded film must hold every captured frame. It must also decode as the same system’s render from an empty cache on as many cores as decodes, since the encoder’s output follows the segments that the system cuts and the cores it has. The sound is compared with that of the render from scratch. It must have the same tracks and channels, lengths within a frame, and loudness within 0.5 LU overall and within 1 dB in its 20-ms envelope.

The checks. A build’s verdict comes from machine checks of the film and a lint of its sources (Table S1). Most checks read what a frame draws, its texts with their boxes and its image draws. They sample the film every 40 ms, and the overlap check samples it every 0.5 s. Three checks read the pixels of sampled frames. Two checks read the sound and the encoded film and therefore need the film. A passing build runs these two after its render (FilmCHECK in Alg. 1). An error stops the build, and a warning is returned with the film. Across versions, a check keeps its record at a sampled time under the cascade’s first two tests, that is, when no changed script reaches that time and the values read by the frame at that time are unchanged. After a change to any other file, the checks take every record again.

CheckReports
A frame’s texts and image draws
Overlaptext over a subject, another text or a subtitle, outside the safe area, or cut by the frame edge
Readingtext on screen for less time than reading it takes
Timingtext shown more than 0.5 s before the narration says it
Subtitlesa subtitle over a picture without a box
Cutsa picture still moving at a cut, or filling the frame for under 1 s
Resolutionan image drawn larger than its resolution supports
Databars out of proportion to their labels, numbers absent from the data files
Pixels of sampled frames
Framesblank, dark or blown-out frames, every 0.5 s
Stylea scene’s frame far from the style’s colors
Determinisma scene’s frame that differs when rendered again in another order
The sound and the film
Duckingmusic not lowered under the voice
Fileloudness, true peak, black frames
The sources
Timelinecues or subtitles outside the film, locked items changed
Lintthe project’s conventions for storyboard, assets, style and scenes

Table S1. The checks behind a verdict, by what each reads.

Baselines in detail. Input hash re-renders every frame of a version that changed. Scene windows re-render the frames inside the old and new windows of every scene whose file changed. When a file that no scene owns changed, they re-render every frame. Read sets re-render a frame when the files of the parts it draws or the set of parts it draws changed, or when it read a value that changed. Kamishibai-style fingerprints follow the hand-written tokens of the incremental renderer kamishibai [29]. Typical fingerprints key a part by its file, its own start and end and the local time. Careful fingerprints add every shared script and the whole timeline. The animation engine Manim [63] keys an animation call by hashing the call’s arguments and the scene’s objects as they stand. Manim-style per-call caching keys a scene in the same way, by its file, the shared scripts, its length, every value its frames read and every value its script read at load, such as a scene’s start or a line’s timing. It does not key a scene by where the scene sits, and it keys the subtitles also by the shared scripts that style them. We checked this cache against Manim CE itself on four kinds of edit. Complete keys cut the film into scenes or into narration lines and reuse a unit whole when the same sequence of frame keys was rendered before anywhere in the film. They are therefore exact and follow units in time. They bound what a cache of whole scenes or lines with complete keys could reuse. The similarity rule reuses a frame as training-free caches reuse features between similar denoising steps [38]. It renders every frame at a quarter of its size and shrinks the frame to a 32 × 18 gray thumbnail. It reuses the previous version’s frame at the same time when the mean absolute difference of the two thumbnails’ gray levels (0–255) is below a threshold, which we sweep from 0.1 to 8. HyperFrames [26], an HTML video framework for agents, renders ports of the Remotion track’s versions, each port at 1080p with as many frames as Remotion’s own render.

What the scrub keeps. Every replaced file becomes a placeholder of the same size or length, chosen by the original’s content hash. The same original therefore always becomes the same placeholder, and the scrub keeps which frames change between versions. A font is kept when its license allows. Otherwise a substitute font holds every character the narration uses. Voices become tones over the samples where speech was, so the narration’s cut points and the timeline are unchanged. Speech-recognition caches are re-keyed. All numbers in the paper are computed on the scrubbed sessions, which are the ones released.

Statistics. The Remotion track’s edit classes differ from the real track’s by 0.11 in total variation, and its think times differ from the real track’s by 0.06 in the Kolmogorov–Smirnov statistic (Table S2). Table S5 gives the Remotion track’s wait by how much of a film a build changes.

RealModelsSynthetic
Sessions123206
Versions1,525215150
Tool calls2,078289150
Builds1,314188150
Calls per session16.914.425.0
Chinese / English69 / 5416 / 40 / 6
Film (s)80.8 [52.0, 145.8]79.1 [56.7, 177.8]31.9 [24.5, 40.4]
Build (s)25.5 [3.1, 63.6]14.8 [2.1, 49.6]–
Think time (s)8.0 [0.0, 87.5]15.3 [0.0, 119.2]12.8 [4.7, 105.3]
Builds per session10 [5, 16]––
Rounds per session4 [3, 7]––
Model cost per session ($) | 2.85 [1.73, 6.45] | – | –
Edit class: new or removed files39.0%41.1%33.3%
Edit class: narration lines26.1%23.2%27.1%
Edit class: one scene’s script12.6%16.1%20.1%
Edit class: shared scripts or data20.4%18.4%15.2%
Edit class: a style script0.3%0.6%0.0%
Edit class: no change1.6%0.6%4.2%

Table S2. The three tracks of EditLoop: sessions, versions, tool calls and builds; films, builds and the agent’s think time before a call in seconds, median [10th, 90th percentile]; the share of builds by edit class. Models: Claude Sonnet 5.5 and Haiku 5.5.

Rules. Replays are closed-loop. Caches start cold and are never shared across sessions or replays. A system’s timings count only if every call passes the gate. We built the system and set its parameters on the development split. The early render’s control group and rule, the fast checks, the page’s part of the key and the place of the key evaluation were designed with the test split’s replays in view. The data come with a key trace, which gives every frame’s key and read values for each rendered version, renumbered within the session. They also come with an OpenTelemetry export, with one invoke_agent span per session and one execute_tool span per call. A datasheet and Croissant metadata describe the data.

Why the keys are sound, and what is audited

The guarantee. On one renderer configuration (runtime, browser, rasterizer, frame size), if a frame’s key equals a key rendered before, its pixels equal the pixels rendered under that key, provided that (i) the frame’s drawing is deterministic, (ii) the key holds the frame’s structural inputs (the page, the set of registered parts and their order), (iii) every part used only the supported interfaces below, and (iv) the rasterizer draws the normalized commands as the normalization rules below characterize it. This is Property 1 with each of its provisos spelled out. A part that uses an interface outside the table below is unkeyed for that frame and always rendered.

How each interface enters a key (Canvas 2D). Each part draws its share of the frame at time tt in its function render(t).

InterfaceKey
Drawing calls (fillRect, fill, stroke, clip, fillText, drawImage, putImageData, . . .)method, arguments, and a snapshot of the state at the call
State (save/restore, transforms, alpha, compositing, filter, font, text alignment, line styles, dashes, shadows, smoothing)a state stack kept in call order, snapshot at each drawing call
Paths and Path2Dthe command sequence with its transforms, keyed when filled, stroked or clipped
Gradients and patternsconstruction arguments and every color stop up to use; pattern source by content and its transform
Images, fonts, data filescontent hash of the asset
Off-screen canvases as sourcesthe hash of their command sequence since creation or the last whole overwrite
getImageData, putImageDatathe written bytes
Commands that set state but never drawdropped at the part’s end (no pixels)
Unregistered image URLs, video sources, WebGL canvases as sources, off-screen canvases changed outside render(tt), resizing a canvas mid-framenot keyed: the part is rendered
DOM outside the canvas, WebGL / three.js, post-processingglobal inputs

Determinism. Reads of Math.random, Date.now and performance.now inside render(tt) are recorded. The checks render one frame of every scene twice, in different orders, with the unmodified runtime. They compare the two renders’ keys, or their full-size pixels for unkeyed frames. The checks report the recorded reads as defects.

Normalization rules. The rasterizer draws text from its glyph atlas at a baseline snapped to whole device pixels, so such text is keyed by the snapped baseline. The drawing itself is unchanged, and the key follows the rasterizer. This snapping applies to text drawn by fillText without a width limit, under an axis-aligned transform with positive scales and no filter or shadow, at a glyph size of at most 256 device pixels, the atlas’s limit, and with a device baseline at least 0.02 pixels from a rounding boundary. Any other text enters a key with its coordinates as given. In a sweep over fonts, sizes, equal and unequal scales, all baselines, fill and stroke, color, alpha, spacing and the atlas edge, every such key stands for one picture. An off-screen canvas or layer forgets its pixel history when it is overwritten whole from a clean state, by a whole-canvas clearRect or putImageData or by an opaque fillRect under the identity transform. The canvas’s hash then restarts with its drawing state. Any other drawing keeps the history in the hash. Chromium keeps a raster state per 2D canvas that follows what the canvas drew before, and resizing the canvas to zero and back clears this state. Every canvas (the main one, the caption layer and every other layer) is therefore resized to zero and back before each captured frame. Three renders of a version then agree frame for frame. A frame evaluated only for its key is drawn on contexts reset in place. It is drawn in full when its drawing reads pixels back or when the page holds a context other than 2D. The 2D canvas is rasterized in software at full scale. On Remotion pages, what a frame draws is the laid-out page, with its elements under their computed styles and its resources by content. An element that cannot be visible, with opacity zero, is keyed by its box alone. Text on these pages is drawn in grayscale, since with subpixel text a frame’s pixels depend on what the page drew before.

The cascade in full. Algorithm S1 gives the keys and the film of a version. The algorithm’s levels are the stages of Figure 4. Static impact is level 1, values read is level 2, the frame key is level 3

Algorithm S1 keys and film of a version

Figure S1. Algorithm S1 Keys and film of a version PP (symbols in Sec. S2).

Algorithm S1 Keys and film of a version PP (symbols in Sec. S2).

Input: PP; last key pass QQ with keys ktQk_t^Q, read sets RtR_t, stores of frames CC, segments SS, films F\mathcal{F}

Output: film FP\mathcal{F}_P

  1. if P∈QP \in Q then return F[P]\mathcal{F}[P]

  2. Ω←ωQ(D)∪ωP(D),D=P⊖Q\Omega\gets\omega_Q(D) \cup\omega_P(D), D = P \ominus Q

  3. K←{t∉Ω:ktQ≠⊥,ηP(Rt)=ηQ(Rt)}K \gets\{t \notin\Omega: k_t^Q \ne\perp, \eta_P(R_t) = \eta_Q(R_t)\}

  4. if ∃t∈U(K):κP(t)≠ktQ\exists t \in U(K) : \kappa_P(t) \ne k_t^Q then K←∅K \gets\varnothing

  5. kt←ktQk_t \gets k_t^Q if t∈Kt \in K else κP(t),t∈TP\kappa_P(t), t \in T_P

  6. for s∈Seg⁡(P)s \in\operatorname{Seg}(P) do

  7.    if ks∈Sk_s \in S then Fs←S[ks]F_s \gets S[k_s]; continue

  8.    It←C[kt]I_t \gets C[k_t] if kt∈Ck_t \in C else ρP(t)\rho_P(t), kept in CC if kt≠⊥k_t \ne\perp; t∈st \in s

  9.    Fs←enc⁡(Is)F_s \gets\operatorname{enc}(I_s), kept in SS if Is≠ksI_s \ne k_s

  10. return F[P]←Fs1∥⋯∥Fsm\mathcal{F}[P] \gets F_{s_1} \mathbin\Vert\cdots\mathbin\Vert F_{s_m}

and the render is level 4. Let TPT_P be the frame times of PP. Let QQ be the last key pass in the same configuration, the last version whose keys were computed, with key ktQk_t^Q and read set RtR_t for each frame tt. Let D=P⊖QD = P \ominus Q be the files that changed. With no Ω\Omega, every key is evaluated. A scene’s script draws only inside the scene’s time window. Let Ω\Omega be the union of the windows ω\omega, widened by one frame, that the parts reached by the changed scripts have in Ω\Omega and in PP (Alg. S1). A frame outside Ω\Omega therefore keeps its key if no value it read changed (Alg. S1). While rendering, the runtime records through a read probe the values RtR_t that each frame reads, such as the timeline, the style, a part’s configuration or an asset entry. The runtime then compares their hashes ηP(Rt)\eta_P(R_t) and ηQ(Rt)\eta_Q(R_t), so editing one entry of the style invalidates only the frames that read that entry. Values read at load time are recorded per script rather than per frame. A script whose load-time values changed starts the reach as a changed script does, so the windows of the parts that this script reaches join Ω\Omega. A change that no part owns, such as a data file read whole, the page or the runtime, reaches every frame. The film’s length counts as a value read by the frames that use it. Level 2 cannot apply when PP loads other resources than QQ or when a value read at load has no known reader. Then no key is kept, and every frame goes to level 3. Let KK be frames that keep their keys. Before these keys are used, up to four frames U(K)U(K) drawn at random from KK are evaluated afresh. A fresh key that differs from the kept one sends every frame to level 3 (Alg. S1). Property S1 states when a kept key is the key that level 3 would compute. The audit tests this property on the film at hand. In the runs we report, 5,736 key passes kept 1,114,094 keys, and each kept key passed both tests.

The remaining frames get the key κP(t)\kappa_P(t) of the commands they issue (Alg. S1), evaluated without capturing the frame. A frame that draws through an interface outside the supported set gets no key, written ⊥\perp. Every part that draws the frame, such as a scene, an overlay or a caption, records the drawing commands it issues. Each command is recorded as its method, its arguments and the drawing state, which holds the transform, styles, font, clip and compositing. Images and fonts enter the key by their bytes in the version’s immutable store. Gradients and off-screen canvases enter by their content, and the page around the canvas enters by its elements and styles. The key hashes the parts in drawing order. Outputs are stored per renderer configuration. On a recorded film of 1,885 frames, the key pass costs 2.7 ms of CPU per frame, against 81 ms for a full render with sound and encoding. Levels 1–2 skip even the key evaluation for the frames they keep. In the runs of Sec. 4, the key pass takes a median of 1.0 s per film on 8 cores and 0.6 s on 32. That is 4.3% of a render’s time on 8 cores and 5.2% on 32, and 4.0% of a film’s wait on 8 cores and 4.1% on 32.

Property S1 (Kept keys). Let QQ, on the configuration and frame rate of PP, hold ktQ=κQ(t)k_t^Q = \kappa_Q(t). If t∉Ωt \notin\Omega and ηP(Rt)=ηQ(Rt)\eta_P(R_t) = \eta_Q(R_t), then κP(t)=ktQ\kappa_P(t) = k_t^Q, provided the assumptions of Property 1 hold, each part is attributed to the script that registers it, a script affects frames outside its parts’ windows (an overlay’s window is the film) only through the names it declares, and the probed data (the timeline, the style, asset entries) reach a part only through reads the probe records: the part’s own while drawing and its scripts’ at load.

Why a kept key is the level-3 key. Every key of QQ was evaluated or kept under Property S1, so by induction ktQ=κQ(t)k_t^Q = \kappa_Q(t). On one configuration, κ(t)\kappa(t) hashes the frame’s size, background, fonts, page and camera, then each drawing part’s name, z-order and commands in order. Each part starts from a reset drawing state, so by Property 1’s determinism its commands are a function of its code, window, tt, load-time values, reads while drawing and assets. A scene draws only inside its window. Ω\Omega holds the windows, in QQ and PP, of the parts of every script reached through declared names from a changed script. A script counts as changed when its code or its load-time reads changed, and a data script when its values changed. Ω\Omega holds every frame if a reached script registers an overlay or writes into shared state. By the third proviso, no changed script affects a frame t∉Ωt \notin\Omega, so the same parts draw in the same order, with the same code, windows, load-time values, fonts, page and camera. By the fourth proviso, data reach these parts only through those load-time values and through RtR_t, which holds their reads while drawing, the frame size and the background, and ηP(Rt)=ηQ(Rt)\eta_P(R_t) = \eta_Q(R_t). The page, style sheets and font files belong to the configuration. A changed asset file either comes with changed entries that its readers read or sends every frame to level 3. Equal inputs give equal commands, so κP(t)=ktQ\kappa_P(t) = k_t^Q. Read sets (Tab. 3) tie a frame to its reads while drawing and to its scene’s file. They miss a change through code that the frame calls in another scene’s file, and they miss a changed value read at load, such as a scene’s start, so they reuse stale frames. Of the 9,704 stale frames they reuse on the adjacent versions of Tab. 3, 95.2% lie in the windows that the changed scripts reach. The other 4.8% lie in the windows reached from a script whose values read at load changed. All of them lie in Ω\Omega, so levels 1–2 refuse every one. Table S3 lists what enforces each condition. Over 1,998,204 frames of 355 pairs, the key audit finds every kept key equal to its fresh evaluation (Sec. 4.4).

ConditionHow it is enforced
ktQ=κQ(t)k_t^Q = \kappa_Q(t)LL is never kept; keys are taken after the loads a draw asked for; a kept key carries its read set forward, and every kept key passed both levels (induction over key passes)
Configuration, frame gridone index per runtime, browser, fonts, page, size, scale and the renderer’s frame rate; a size or background set by a script is read by every frame
Same parts, names, orderQQ holds, in QQ and PP (±1 frame), the windows of every part a reached script registers; an overlay reached, two parts of one name, or a script added or removed: level 3
Codereach follows the names a script declares or binds (declarations at any depth, implicit globals, members of the global object under any of its names, string property names); a computed global access reaches every name; a write into a shared state or the page: level 3; recorded per script, cues included; a script whose values changed starts the reach
Values read at loadthe timeline, the style, the asset entries, sound durations, the film’s length, the registration, size and background are probed per frame, raw reads and property queries included; an opaque value or a write while drawing: no key
Values read while drawingevery canvas reset before each frame, each part drawn between a save and restore, an inherited path or an off-screen canvas drawn twice: no key; Math, random, Date, now, performance.now while drawing: no key
Start stateevery canvas reset before each frame, each part drawn between a save and restore, an inherited path or an off-screen canvas drawn twice: no key; Math, random, Date, now, performance.now while drawing: no key
Fonts, page, camerafaces by their bytes, the page by its elements and styles after each frame, the camera’s value: all in the key; their files in the index
Assetsby the hash of the bytes decoded; a file changed without its registry entry: level 3
Changes no part ownsthe page, style sheets, fonts, runtime and browser in the index; a data file read whole: level 3

Table S3. Table S3: What enforces each condition of Property S1; “level 3” sends every frame to be evaluated.

Level 4 renders the film (lines 6–9). The film is cut into segments Seg⁡(P)\operatorname{Seg}(P) at scene starts and every second after each scene start. A segment ss whose sequence of keys ksk_s was encoded before is copied from the segment store SS. The other segments are encoded (enc) from their frames ItI_t, each taken from the frame store CC by its key or rasterized (ρP\rho_P). Unkeyed frames and the segments holding them are never stored. A version built before returns its film whole from the film store F\mathcal{F} (Alg. S1). Segments hold pictures only. The narration is voiced again for the lines that changed, and the sound is mixed for

every version and muxed with the segments. A segment whose keys are unchanged is therefore copied under a new narration. Work ahead runs the same render without sound and writes no film.

Property S2 (Fewest captures). Given the outputs stored so far, none evicted, Alg. S1 captures one frame for each distinct key of PP that has no stored output, and every newly framed; no caching the same outputs that reuses a frame only under an equal key captures fewer.

A frame whose key is already being captured waits for that capture, so each missing key is captured once.

What is reused. A frame store holds the rendered frames by key, per renderer configuration. A build takes from the store every frame whose key the store holds and renders the rest, each missing key once. The film is cut into segments at scene starts and every second after each scene start, so a moved scene keeps its segments. A segment whose keys were encoded before is copied, and a version built before returns its film whole. The checks reuse their results through the cascade’s first two tests.

Scheduling details

Mechanisms and when each is used. The check’s text sweep samples the film every 40 ms, and their checks sample it every 0.5 s. Within a build, the sweep runs over kk browser pages in parallel (par), with k=8k = 8 on 32 cores or more and k=max⁡(2,min⁡(4,c−4))k = \max(2,\min(4,c-4)) on cc cores below 32. The parallel sweep is used on c≥6c \ge6 cores without a software-only rasterizer. The source lint runs alongside the checks (dag). The fast checks (vp) draw a sampled frame on reset contexts, as the evaluation of a key does, instead of on a new canvas. They draw a frame whose code reads pixels back in full. The fast checks also keep the source map, which maps drawn objects to source lines, off the verdict’s path. A check without errors returns at once, and a check with errors scans the frames its errors name for their source lines. After the verdict, a separate process at the lowest priority rebuilds the map. The early render (opt) starts alongside the checks on pages of its own, in a control group of its own marked idle. A passing verdict gives the group a normal share and the first claim on memory. A failing verdict kills the group whole. A failure known from the files before the verdict, such as a stale narration text or a lint error, stops the early render at once. The early render starts when p^>θc\hat{p} > \theta_c (S1), with p^=(a+4m)/(n+4)\hat{p} = (a + 4m)/(n + 4). Here nn counts the session’s last five builds of the same kind of edit, narration changed or not, or the last five of any kind while that kind has fewer than two. The count aa holds those among them whose checks passed. The rate mm is the development split’s pass rate, 1/331/33 before a session’s first build and 186/360186/360 after it. The threshold θc\theta_c is interpolated in log⁡2c\log_2 c between the machines of Table S4 and held at the ends of that range. A session’s first build thus never starts the render early. A later build always does on 4, 32 and 64 cores, and on 8 cores unless the five builds counted all failed. The capture workers evaluate the keys, each worker for its own segments, instead of a pass before the capture (kw). On machines below 16 cores, builds fail fast (ff). The data, style, determinism and timeline checks, which seldom fail, then run only once the other checks found no error that stops the build. Operations run at the priorities of their consumers (pri), which are normal priority, the idle group and nice 19. Within a render, the audio chain runs alongside the frames (aud), capture pages open early (pre), each worker encodes a segment while it shoots the next (enc), and the workers are sized to the machine (wk). Rebuild uses every mechanism that applies on the machine except par, dag, vp, opt, kw, ff and pri. It reuses only a whole film whose version did not change. A shared execution service with warm pages serves its callers in turn. Renders get no fixed share of the cores.

Coresddssθc\theta_c
40.020.140.14
80.100.360.25
160.210.610.28
320.220.850.21
640.130.880.13

Table S4. The early render alongside the checks: the checks’ slowdown dd, the share ss of its rate the render keeps and the threshold θc\theta_c of Eq. (3).

Within a build: the verdict first. On half of the builds the agent waits only for the verdict, whose checks sweep the whole film. CodeReel runs the checks first and in parallel. Their sweep is cut by time over several browser pages, and the lint runs alongside the sweep. The fast checks of CodeReel also leave out what a verdict does not need. The checks that read what a frame draws, not its pixels, draw their samples as the evaluation of a key does (Sec. 3.2). The map from drawn objects to source lines is built after the verdict. Where cores are scarce and the checks that seldom fail would delay the verdict, a build also fails fast, as in test prioritization [56, 60]. The checks that seldom fail then run only once the others found no error, and the build answers at the first errors that stop it.

Within a build: the render as a bet. Starting the render alongside the checks is a bet on the outcome, like the sandboxes that agent serving prewarms [74]. The early render saves render time when the version passes and slows the checks in each case. At idle priority, the render slows the checks by a fraction dd through the memory, kernel and I/O they share, and it keeps a share ss of its own speed. The bet therefore pays when the version passes with probability above θc=d/(s(1+d))\theta_c = d/(s(1 + d)) (Sec. S3). Idle priority keeps the bet cheap. The measured θc\theta_c is 0.25 on 8 cores and 0.21 on 32. Algorithm 1 takes the bet when p^>θc\hat{p} > \theta_c, where p^\hat{p} estimates that probability from the session’s last builds. A session’s first build, which rarely passes, thus waits for its verdict, and later builds render early (Fig. 1c). The render starts early in 88.9% of all builds on 32 cores and in 87.6% on 8.

The verdict first, argued. Starting the render alongside the checks delays the verdict by δ\delta whatever the outcome. The version passes with probability pp, and when it passes, the early start saves gg of the render’s own time. The expected waits with the render started early and after the verdict therefore differ by

E[Wpearly]−E[Wpafter]=δ−pg,(3)\mathbb{E}[W_p^{\mathrm{early}}] - \mathbb{E}[W_p^{\mathrm{after}}] = \delta- p g, \tag*{(3)}

and starting early pays when pg>δp g > \delta. The following property holds in this model.

Proposition S3 (Verdict first). On cc cores where operations preempt at no cost, fit in memory and interfere only by taking cores, running the verdict’s operations at strict priority finishes the verdict when the same order of those operations finishes it with nothing else running, and starting the film’s operations on the cores it leaves idle, instead of after it, delays neither the verdict nor the film, whose frames are captured independently; then δ=0\delta= 0, and starting early never lengthens the wait.

The verdict’s operations get every core they can use whatever else runs, so they run as they would alone. Film work done before the verdict only shortens what is left of the film after the verdict, since no frame waits for another. By the same argument, work ahead in the mint takes cost the next build nothing in this model, and it saves the next build every rendered frame that the next version draws. On a real machine, the checks also share memory, kernel and I/O with a capture running alongside them. While both run, the checks advance at 1/(1+d)1/(1 + d) of their speed alone, and the render advances at a share ss of its own speed. Each second of overlap therefore delays the verdict by d/(1+d)d/(1+d) seconds and saves ss seconds of the render, however long either runs. Hence δ/g=d/(s(1+d))\delta/g = d/(s(1 + d)), and by (S1) starting early pays when p>θc=d/(s(1+d))p > \theta_c = d/(s(1+d)). With the render in the idle group, d=0.10d = 0.10 and s=0.36s = 0.36 give θc=0.25\theta_c = 0.25 on 8 cores, and d=0.22d = 0.22 and s=0.85s = 0.85 give θc=0.21\theta_c = 0.21 on 32 (Tab. S4). After a pass, a render started early runs at normal priority and first in the memory queue. The checks that need the film (FilmCheck) run after the render.

Across agents sharing a machine. Under the capacity constraint, the builds of all agents on a machine draw cores and memory from one ledger sized from measured footprints. Agent serving similarly shares servers among agents [70] and meters resources per tool call [76]. A render’s workers follow what the render is granted, and work ahead yields when blocking work cannot fit. The ledger’s entries follow the memory admission below.

Memory admission. A render asks a ledger, kept per memory budget, for the memory of its plan. This memory is estimated from measurements on this machine: 0.4 GB plus 0.9 GB per capture worker at 1080p, 5 MB per second of film for the audio chain alongside the frames, and 0.15 GB per warm page held by the execution service. The workers are first capped by the cores the render may use and then sized by the memory granted. The audio runs alongside the frames only if it fits in the grant. When the grant falls short of the plan, the render first drops the audio’s overlap and then workers.

Pages without the GPU. Chromium gives every browser a GPU process. With the NVIDIA driver, these processes wait on a lock of the driver that all of them share, whatever cores or GPU they use. On a 29 s film at 1080p, three renders at once each took 1.49× as long as one render alone. A film whose code never asks for WebGL is shown with the GPU off (–disable-gpu –disable-software-rasterizer), so no process opens the driver. Its Canvas 2D is rasterized on the CPU at full size either way, so the frames are the same (8,425 frames of four films). No render then waits on the lock. A render takes 9.1 s instead of 15.5 s, and three renders at once each take 1.03× as long as one. Every system in Sec. 4 runs this way, and the mode is part of every cache of pixels. A film counts as one that may use WebGL when its code mentions WebGL anywhere. Such a film is drawn by SwiftShader, which runs the GPU interfaces on the CPU, with the Vulkan loader shown only SwiftShader’s driver, so no process opens the graphics device either. Its 2D canvases are rasterized on the CPU as in every other film, since on SwiftShader’s GPU path a canvas’s pixels depend on what the page drew before. Two renders from scratch of one version then agree frame for frame. WebGL frames are never keyed and are always rendered afresh. On the adjacent versions of a test session that draws with WebGL, every frame equals a render from scratch.

Interference. A capture running alongside the checks shares the cores and the node’s memory, kernel and I/O with them. Table S4 gives what this sharing costs with the capture in the idle control group, on machines of 4 to 64 cores. It compares the time of the checks and lint of one build of a development film with their time alone, and the capture’s frame rate with its rate alone. Each value is the mean of five repetitions. With the capture niced to 10 inside the build’s own group instead, dd is 0.43 on 8 cores and θc\theta_c rises to 0.67.

Co-location conditions. All conditions run inside one scope that sets the machine’s cores, a CPU quota and a memory cap without swap. The scope’s memory events, its kills, are kept. Uncoordinated execution has no priority classes and no ledger, and it runs one executor per session. Niced renders add the priority classes of Sec. 3.3 and nothing else. One control group per call runs like uncoordinated execution but puts every call in a control group of its own at equal weight. Each session’s executor gets a control group of its own for its daemons. CodeReel has one ledger of the cores and memory, the priority classes, and one executor for all sessions, which serves its callers in turn. Sessions arrive at fixed offsets. Each session replays its calls closed-loop with a quarter of its recorded think time. Each run takes eight cores of the upper hyperthread half of one socket, whose siblings our jobs leave unused.

Registration and the machine

Frameworks and hardware. Every system renders the same programs at 1080p and 30 frames per second. These are cv.js programs, written for our Canvas 2D runtime and run in headless Chromium, and Remotion [59] programs, written in React. The machines are 32, 8 or 4 of one server’s cores, with 2 GB of memory per core. 32 cores are abundant, since a render starts fewer workers than there are cores. 8 cores, a laptop’s size, are constrained, since a render can use more workers than cores. 4 cores are saturated, since frame capture alone fills them. Each session runs in its own control group on an AMD EPYC 9755 machine. Every system renders on the CPU, for the reasons given under Pages without the GPU (Sec. S3).

Registration. We registered the protocol before any formal run. It fixes the split, the machines, the gate and every test. The tests on 8 and 32 cores form the primary family under Holm’s procedure [24]. The registered decisions are these. Exactness holds if every pair, at least 1,800 random edits and the 32 narration edits are exported and every frame of their incremental renders equals a render from scratch. For 8 and 32 cores, the upper end of each ratio’s interval must lie below one, one-sided at 2.5% for the family under Holm’s correction. No resample’s ratio reaches one. The largest of the 2,000 resampled ratios is 0.68 on 32 cores and 0.72 on 8. For real agents, the measure is the geometric mean over pairs of the ratio of within-session median waits per build. It is taken on the 14 pairs whose topics development never touched, with all 26 pairs as a secondary analysis. The film’s quality is reported as paired differences. Per build, the agent’s wait under CodeReel relative to its wait under Remotion on the same build has a median of 0.56× on 32 cores (95% CI 0.53–0.59) and 0.52× on 8 (CI 0.50–0.56). Table 2 gives the ratios of total waits.

The machine. The machine has 512 hardware threads on two sockets. Timed replays ran in lanes of disjoint cores on the upper hyperthread half of one socket, whose siblings our jobs left unused. Both systems of a session ran back to back in one lane. The scaling runs of Fig. S1 ran one replay at a time.

More results

Comparison with existing systems

The size of an edit. On EditLoop’s Remotion track, the gain follows how much of a film a build changes (Table S5). We group the builds of three repeats by the share of the film’s frames that CodeReel renders. The agent waits 0.35× as long under CodeReel as under Remotion’s renderer when CodeReel renders no frame, 0.46× when CodeReel renders under 5%, 0.56× when it renders 5 to 20% and 0.92× when it renders 20% or more (CI 0.89–0.96, resampling the sessions).

Frames renderedBuildsSessionsWait
None16260.35
Under 5%16260.46
5–20%7860.56
20% or more4860.92

Table S5. The Remotion track’s wait under CodeReel relative to Remotion’s renderer, by the share of the film’s frames a build renders; builds count the three repeats, and intervals resample sessions, each with its three repeats.

An agent’s Remotion sessions. The gain on Remotion holds for an agent’s own edits. Claude Code with Claude Opus 5.5 made 12 films in Remotion, each through three rounds of stack change requests. These sessions hold 58 versions, 65 builds and 64 delivered films. Replayed three times on 8 cores, the agent waits 0.67× as long under CodeReel as under Remotion’s renderer (CI 0.52–0.80, resampling sessions, each with its three repeats). On builds that deliver a film, the agent waits 0.67×0.67\times as long. CodeReel uses 0.69×0.69\times the CPU of Remotion’s renderer and renders 48.6% of the frames. Of the 192 films the three replays deliver, 175 equal a render from scratch frame for frame. The others belong to one session, whose film Remotion’s renderer draws differently from run to run.

Mean wait per build against the session’s cores for Rebuild and CodeReel

Figure S1 (PDF p. 16). Mean wait per build against the session’s cores, Rebuild and CodeReel; bars are 95% intervals over topics.

Wait across machines and agents

Other models’ sessions. The recorded sessions of the other models differ from Claude Opus 5.5’s in how often a build fails and in how much of a film a version changes. These are the quantities on which the two parts act. On the same ten test topics, a check stops 53.1% of Sonnet’s builds, 57.0% of Haiku’s builds and 61.2% of Opus’s builds. The median share of a later film’s frames that no earlier version drew is 83.4% for Sonnet, 70.7% for Haiku and 78.6% for Opus. The ratios of Tab. 2 follow that mix. They are 0.540.54–0.62×0.62\times for the sessions of other models and harnesses and 0.38×0.38\times for Opus 5.5 on the † topics, nine topics on which each agent ran its first session. The parts’ own ratios on failing builds and on builds that deliver a film follow the mix as well (the last block of Tab. 2). In Opus 5.5’s † sessions, which render a third of the frames, the agent waits least (Fig. 6). Six of the † topics are development topics. Table S6 gives the wait under CodeReel by machine and by agent, with its intervals (†: each agent’s first session on nine topics).

Sensitivity. Table S7 splits the wait of Tab. 2 by the edit a build follows and by its place in its session. Every class of edit gains. On 32 cores, the ratio runs from 0.62×0.62\times after an edit of one scene’s script, which static impact confines to that scene’s window, to 0.68×0.68\times after an edit of a data file, which more frames read. The two rare classes gain as well. The ratio is 0.55×0.55\times after an edit of the style and 0.29×0.29\times for a build of an unchanged version, whose film both systems return whole. A session’s first build has an empty cache, and on it the agent waits 0.56×0.56\times as long, through the verdict first alone. From a session’s sixth build on, the agent waits 0.64×0.64\times as long. On builds that deliver a film, the ratio holds across film lengths. By thirds of length on 32 cores, it is 0.71 in the shortest third, 0.71 in the middle third and 0.71 in the longest. For builds that fail a check, the gain grows with the length, from 0.48×0.48\times in the shortest third to 0.31×0.31\times in the longest. Over these thirds, Rebuild’s checks take 4.2 to 7.3 s, while the checks under CodeReel, which reuse their results, take 1.2 s in the longest third.

Buildsnn32 cores8 cores
First of a session (cache empty)700.560.60
After an edit of
one scene’s script470.620.64
narration lines1710.660.66
files added or removed2770.620.66
a shared script740.660.72
a data file520.680.76
the style40.550.61
nothing (built again)70.290.19
By place in the session
second700.550.66
third to fifth2040.670.72
sixth and later3580.640.65
Every build7020.640.67

Table S7. The wait under CodeReel relative to Rebuild by the edit a build follows and by its place in its session (ratios of total waits).

What drives the gain, within runs. In the run of the last block of Tab. 2, a session’s change in wait follows the frames it saves. The slope is 0.37 (CI 0.27–0.48) from Rebuild to reuse alone and 0.40 (CI 0.30–0.51) from the verdict first alone to CodeReel. With the verdict first off or on, this is the slope of Figure 6. Per stage (Tab. S8), reuse alone cuts both the checks, which reuse their samples, and the capture. Reuse alone cuts the capture to 0.87×0.87\times Rebuild’s time while rendering 34.3% fewer frames. The verdict first alone cuts the checks to 0.59×0.59\times. CodeReel cuts the checks to 0.26×0.26\times and the capture to 0.91×0.91\times.

One mechanism removed. Every mechanism carries part of the gain. On 32 cores, over 70 topics, the agent waits 1.22×1.22\times as long under CodeReel without the verdict first as under CodeReel (CI 1.19–1.26). Without the fast checks, the agent waits 1.04×1.04\times as long (CI 1.02–1.06). Without reuse, it waits 1.05×1.05\times as long (CI 1.01–1.09), with 1.27×1.27\times the CPU. This last arm is the scheduling part alone, and under it the agent waits 0.65×0.65\times as long under Rebuild (CI 0.64–0.67).

Across sessions. The agent waits less in sessions that render fewer frames again (Fig. 6a). The least-squares line is wait = 0.38 + 0.37 · frames, with both quantities relative to Rebuild (slope 95% CI 0.30–0.44). The ablation separates what reuse and scheduling each contribute. Opus 5.5’s sessions on the agents’ nine topics (†), whose edits keep the most frames, gain most. The gain is there from a session’s first build, whose frame store is empty, on 32 and on 8 cores (Tab. S7).

CPU allocation. With 4 to 32 cores on 20 topics (Fig. S1), the render’s workers follow the cores until the rule that sizes them by the film’s length caps them, at 13 workers on these films. The cores beyond serve the checks and the encoders. The wait under both systems still falls from 16 to 32 cores. The advantage of CodeReel grows with the cores. The agent waits 0.75×0.75\times as long under CodeReel as under Rebuild on 4 cores, 0.66×0.66\times on 8, 0.64×0.64\times on 16 and 0.62×0.62\times on 32, as the verdict first spends on the checks the CPU that reuse frees. On the 70 timed topics of Tab. 2, the agent waits 0.64×0.64\times as long under CodeReel as under Rebuild on 16 cores (CI 0.61–0.68).

Think time and work ahead. Work ahead in the agent’s think time shortens the wait further. Replayed with the recorded think time, the agent waits 0.60×0.60\times as long under CodeReel as under Rebuild on 8 cores (CI 0.58–0.63) and 0.59×0.59\times on 32 (CI 0.58–0.61). On 8 cores, this wait is 0.90×0.90\times the wait with work ahead off (CI 0.88–0.93). With work ahead, builds render 19.0% fewer frames, and the wait for films falls by 10.7%.

Starting the render early. We measure the early render on 32 cores, over 70 topics, in a four-arm run with every film gated (1,452 / 1,452). In this run, the rule starts the render early on 88.9% of the builds, and the render keeps 0.85×0.85 \times its speed alongside the checks. When the render never starts early, the agent waits 1.07×1.07 \times as long as under CodeReel (CI 1.03–1.10), and 1.08×1.08 \times as long on builds that deliver a film (CI 1.04–1.13). CodeReel speeds up its key evaluation in two ways, by drawing on contexts reset in place and by evaluating keys in the capture workers instead of in a pass before the capture. Without these two speed-ups, the agent waits 1.07×1.07 \times as long as under the full CodeReel on these topics (CI 1.03–1.10), and 0.66×0.66 \times as long as under Rebuild (CI 0.63–0.69).

SettingTopicsBuildsWaitFailedFilmFrames
32 cores707020.64 [0.61, 0.66]0.39 [0.36, 0.42]0.71 [0.68, 0.74]0.65
32 cores, think time707020.59 [0.58, 0.61]0.41 [0.38, 0.44]0.65 [0.63, 0.67]0.49
8 cores707020.67 [0.64, 0.69]0.43 [0.40, 0.45]0.71 [0.68, 0.74]0.66
8 cores, think time707020.60 [0.58, 0.63]0.43 [0.40, 0.46]0.63 [0.61, 0.66]0.53
4 cores201970.75 [0.70, 0.80]0.46 [0.42, 0.50]0.79 [0.72, 0.85]0.63
32 cores, Sonnet 5.510810.62 [0.55, 0.73]0.47 [0.40, 0.57]0.66 [0.59, 0.79]0.62
32 cores, Haiku 5.5101070.54 [0.51, 0.60]0.46 [0.39, 0.58]0.57 [0.54, 0.61]0.63
32 cores, DeepSeek V4†9950.56 [0.50, 0.62]0.35 [0.29, 0.42]0.67 [0.60, 0.74]0.69
32 cores, Codex CLI†9460.54 [0.37, 0.77]0.27 [0.20, 0.60]0.63 [0.48, 0.80]0.83
32 cores, Opus 5.5†9960.38 [0.28, 0.50]0.32 [0.27, 0.41]0.40 [0.28, 0.53]0.33

Table S6. The first two blocks of Tab. 2 with 95% intervals (2,000 resamples of topics), topics and builds.

StageRebuild (per build)Sequential reuseverdict firstfast checksCodeReel
Wait15.4 s1.510.940.690.820.64
Frames1,3991.000.661.001.000.65
Checks10.8 s0.780.890.590.380.26
Keys (of capture)–00.05000.06
Capture7.1 s1.250.871.071.060.91

Table S8. The wait, the frames rendered and the time per stage in the run of the last block of Tab. 2: Rebuild’s amounts per build, then each arm relative to them. A stage’s time sums the wall-clock time of its operations, which can overlap. The keys’ time is given as a share of Rebuild’s capture time.

Co-located agents. We run kk agents on one machine of 8 cores with 16 GB, in 5 runs per kk, each of which draws the kk sessions and their order at random (Figure S2). Whether an agent gets its films depends on memory. Under uncoordinated execution, the agents’ renders together outgrew the machine. At k=4k = 4 and 8, the kernel’s OOM killer ended 10 of 10 uncoordinated runs and 9 of 10 runs with niced renders. One control group per call [76] keeps the runs alive by killing calls instead, with 1,938 kills at k=4k = 4 and 8, and 238 films are lost. Under CodeReel, with one ledger of the machine’s cores and memory and one shared executor (Sec. S3), every run delivers every film that the recording delivered. These 374 films each pass the gate, and no call is killed. From k=4k = 4, only CodeReel delivers every film (Figure S2).

Figure S2. Films delivered with kk agents sharing one 8-core machine.

Exactness and tightness of reuse

Over the 1,023,902 frames of the reuse study’s 355 pairs, CodeReel reuses no frame whose pixels changed and renders close to the frames whose pixels are new. Every other scheme renders more or reuses stale frames (Table 3). CodeReel renders 63.2% of the frames, which is 1.05×1.05 \times the frames whose pixels are new. Complete keys on whole scenes and on narration lines are exact as well. Complete keys on whole scenes, which bound our per-call and per-scene caches [17, 63] can reuse, render 80.2% of the frames, and complete keys on narration lines render 71.1%. Of the frames an edit changes, 32.6% keep an SSIM above 0.99 to the frame they replace, and 8.1% keep an SSIM above 0.999. The similarity rule of Table 3 therefore leaves 7.0% of all frames stale. These frames miss the agent’s edit (Figure 2, bottom) at a median SSIM of 0.999 to the correct frame (see the similarity rule, below). No frame CodeReel reuses is stale, here or in 2,000 random edits. A key audit checks every key against a lossless capture of its frame, over 2,164,167 frames, of which 98.6% are keyed. No key stands for two pictures, and every kept key audited equals its fresh evaluation.

Stale frames per scheme. Table S9 extends Table 3 with the frames that each scheme reuses although their pixels changed, and with the input hash scheme.

MethodAdjacent versions RenderedAdjacent versions StaleTime-shifting edits RenderedTime-shifting edits Stale
Re-render all, input hash100.0%0100.0%0
Scene windows90.3%22,563100.0%0
Read sets83.8%9,70453.2%7,228
Kamishibai-style, typical [29]63.5%131,40854.0%6,121
Kamishibai-style, careful89.0%15,30599.8%0
Manim-style [63]88.0%3,64299.8%0
Similarity, threshold 0.1 [38]59.7%71,329––
Per scene, complete keys80.2%081.1%0
Per line, complete keys71.1%064.5%0
CodeReel63.2%043.9%0
Pixel truth60.2%043.0%0

Table S9. Frames rendered and stale frames per reuse scheme, on the test split’s adjacent versions and on time-shifting narration edits (cv.js).

Evidence. We compare incremental renders with renders from scratch, frame by frame, on 2,000 random edits of seven kinds on four films (style 379, timeline 376, num 373, draw 257, neutral 255, color 180, text 180). Every edit rendered, and every frame of every edit equals the render from scratch. The same holds over the adjacent versions of the test split (Tab. 3).

Exports. Every one of the 355 pairs and every random edit was exported and compared frame by frame. All 1,023,902 frames of the pairs, reused or rendered, equal a render from scratch.

The similarity rule. At the threshold of Tab. 3, the similarity rule leaves 7.0% of all frames stale. Its stale frames look right to image metrics, at a median PSNR of 41.2 dB and a median SSIM of 0.999, because an agent often changes a few words. In one example, a caption was rewritten from “the weak machine is about 4×4 \times slower” to “the weak machine is about 4×4 \times slower than the strong machine” (translated from Chinese), and the frame the rule keeps has an SSIM of 0.993 to the correct frame. Whatever the rule, many of the frames an edit changes stay near the frames they replace. Of the frames that differ from the previous version’s frame at the same time, 32.6% have an SSIM above 0.99 to that frame and 8.1% have one above 0.999, and the median SSIM is 0.971. A rule that reused every frame above 0.99 would leave 21.0% of all frames stale. The shares are measured on thirty changed frames drawn from each pair of Tab. 3, rendered in both versions and weighted by the pair’s changed frames. Table S10 gives the similarity rule at thresholds below that of Tab. 3, on 23 pairs of the test split drawn at random. The smallest mean difference that two different 32×1832 \times18 thumbnails can have is 1/576. At 0.001, below that value, the rule reuses a frame only when its thumbnail is identical to the previous version’s. A stricter threshold makes the rule render more frames and reuse fewer stale ones. At the strictest threshold, the rule renders 66.7% of the frames, more than the 57.2% whose pixels changed, and still reuses 14 stale frames in 4 pairs. Matching each frame to the nearest thumbnail of the previous version lets the rule reuse a frame moved in time. At the strictest threshold, this matching reuses 1,804 stale frames in 17 pairs. Two frames with the same thumbnail can differ, so no threshold on the thumbnail makes the rule exact.

Time-shifting edits. CodeReel reuses the frames that a time-shifting edit moves. Such a move defeats reuse by time and by

ThresholdSame time RenderedSame time StaleNearest RenderedNearest Stale
Pixels changed57.2%047.7%0
0.151.1%4,146 (14)39.4%15,216 (18)
0.0552.6%3,441 (12)41.2%14,175 (18)
0.0162.9%108 (7)57.4%6,648 (18)
0.00166.7%14 (4)69.6%1,804 (17)

Table S10. The similarity rule at stricter thresholds, on 23 random pairs: frames rendered and stale frames (pairs with one), reusing the previous version’s frame at the same time or the one with the nearest thumbnail.

scene window. On 32 narration edits to four cv.js films (Tab. 3, right), CodeReel renders 43.9% of their frames, against 43.0% whose pixels are new, and reuses no stale frame. Read sets render more and reuse 7,228 stale frames. On two Remotion films with eight such edits each, 120 distinct pictures are new. CodeReel renders 128 frames there, and a cache looked up by time renders 2,373.

Manim CE’s own cache. On one scene of eight animation calls, Manim CE’s cache re-renders every frame of each call an edit reaches. This is the granularity of Manim-style per-call caching in Tab. 3. Manim CE re-renders from 16 of 106 frames after a caption edit to every frame after a change to the text every call draws, and it shows no stale frame. The stale frames of Manim-style per-call caching lie in scenes whose own files did not change but which call drawing code from another scene’s changed file. A per-call key over a call’s own file, the shared scripts and its data cannot see that code, which immediate-mode programs run every frame. Manim instead hashes the objects themselves.

The cost of each edit. On 85.6% of the pairs, CodeReel renders within 5 percentage points of the frames whose pixels are new, with a median excess of 0.1 points (Fig. 6b). Edit-time methods [34, 50] aim for such a cost, close to what the edit changes. Manim-style per-call caching renders every frame of each call an edit reaches.

Real agents in the loop

Real-agent runs. Every session ran on 8 cores with cv.js programs and the scripted user of the registered protocol. The scripted user asks for each round’s changes and accepts the film. Claude Code ran Claude Opus 5.5, and Codex CLI ran GPT-6.1. The Wait and Film ratios of Tab. 4 are geometric means over pairs of per-session medians. The table’s Total column gives each pair’s ratio of total waits, the measure of the replays. Replayed under the protocol of Sec. 4, the sessions that Claude Code recorded live on topics never used in development show the same gain. The agent waits 0.60× as long as under Rebuild on 32 cores and 0.66× on 8.

Film quality of the real-agent pairs. Under the registered scoring protocol, Claude Opus judges the delivered films and lists the faults of each session’s final film. We report the paired differences, CodeReel minus Rebuild. On the 14 pairs whose topics development never touched, the final films’ faults change by −0.29 (95% CI −1.64 to 0.69). For the 12 pairs through Codex CLI, the faults change by −0.58. The judge sees each film’s contact sheets, last frame, narration text and audio levels under a name drawn from a content hash, so the judge does not know which system built the film. Claude Code’s 26 pairs are ten topics run twice and six topics of Code2Video’s benchmark [9] run once. Codex CLI’s pairs are those six topics run twice. The two sessions of each pair ran back to back on the same cores, in an order that alternates between repetitions. Every interval resamples topics with all their pairs. Each final film that a build under CodeReel delivered was rendered again from scratch with the session’s own code, and the two films decode to the same frames.

Ablation study

The two parts shorten the wait in different ways. For the last block of Table 2, we replay Rebuild with one mechanism at a time on 32 and 8 cores over 70 topics, without think time. Reuse removes work. Added alone, reuse renders 34.3% fewer frames with 0.81×0.81 \times the CPU. The agent then waits 0.94×0.94 \times as long on 32 cores and 0.86×0.86 \times on 8, where rendering fills the machine. The verdict first, which runs the checks in parallel and the render alongside them, spends CPU to shorten the wait. With the verdict first alone, the agent waits 0.69×0.69 \times as long on 32 cores and 0.86×0.86 \times on 8. On failing builds, it waits 0.49×0.49 \times as long on 32 cores and 0.60×0.60 \times on 8. The verdict first alone uses 1.12×1.12 \times the CPU on 32 cores and 1.05×1.05 \times on 8. With every mechanism, the agent waits 0.64×0.64 \times as long under CodeReel on 32 cores and 0.67×0.67 \times on 8, and CodeReel uses 0.81×0.81 \times the CPU on 32 cores and 0.76×0.76 \times on 8. Reuse thus returns the CPU that the verdict first spends. With the fast checks alone, the agent waits 0.82×0.82 \times as long on 32 cores and 0.88×0.88 \times on 8. Starting the render early adds to the gain of the verdict first. When the render never starts early, the agent waits 1.07×1.07 \times as long as under CodeReel on 32 cores (CI 1.03–1.10). Without static impact, CodeReel evaluates 1.22×1.22 \times as many keys, and without values read, it evaluates 1.24×1.24 \times as many (see the parts of reuse, below).

The parts of reuse. We turn one part of reuse off at a time on 50 pairs of Table 3. With static impact or values read off, the same frames are rendered. The keys evaluated rise to 1.22×1.22 \times with static impact off and to 1.24×1.24 \times with values read off. Text-baseline snapping saves 534 unchanged frames. Keys that hold a frame’s position in time cost 1.11×1.11 \times the frames on narration edits. We also time CodeReel with one part off at a time on four topics, with every film gated (18/18). Relative to the full CodeReel, the agent waits 1.08×1.08 \times as long with static impact off, 1.03×1.03 \times with values read off and 1.04×1.04 \times with text-baseline snapping off.

Related work in full

Code-to-video agents and benchmarks. Agents make explanatory videos by writing Manim, web or slide programs and refining them with a renderer in the loop [9, 32, 36, 37, 78]. Agents also drive physics simulators and renderers through code [5], mix programs with generative models [39], and program slides and 3D scenes in the same loop [18, 19, 25]. VISTA [44] refines generated videos, LottieGPT generates vector animations as tokens [8], and the Scene Language represents scenes as programs [73]. These works improve what the agent writes and how its output is judged, and some measure tokens and time [9, 36]. None goes beyond its framework’s per-call cache or targets the latency of a verdict. Benchmarks grade the result, and some also grade cost or trajectories [10, 19, 20]. Code2Video-Compass [10], on the same web and Remotion stack, generates a video in one call. Agent traces record tool latencies [77] and are replayed to benchmark serving [33, 53]. EditLoop’s replay instead executes the calls.

Reuse. Training-free caches reuse or forecast features between denoising steps [28, 38, 40, 45, 47, 67, 75]. Edit-time methods compute on the edited region [34, 41, 50, 72] or reuse unchanged regions across editing turns [35]. Serving, graphics and video models skip or reproject work for similar inputs, frames or pixels [2, 13, 21, 31, 49, 55, 64]. All of these methods let their output differ from the full computation’s. Production tools and UI toolkits reuse operator outputs, frames and display lists [1, 15, 16, 62]. Closest to us, Manim keys each animation call by its inputs [63]. Kamishibai fingerprints each frame’s page and reuses the previous run’s frame at the same index [29]. HyperFrames repeats the frames that its timeline predicts to be static within one render [26]. Fourier, a video framework built for agents, fingerprints sources, assets and timing to reuse unchanged scenes, layers and speech, also after a layer moves in time [17]. CodeReel keys a frame by its evaluated drawing commands, normalized to the rasterizer, so frames of imperative code with one global clock and no call or layer boundaries are found again in any version, at any time. Like build systems [11, 48] and incremental computation [22, 23], CodeReel keeps its results consistent with a build from scratch. Its keys, however, come from what a program draws and not from the files the program reads.

Scheduling around agents. Test prioritization runs likely failures first [56, 60]. Agent controllers weigh cheap diagnostics against costly verification [54]. Agent serving places KV caches around tool calls [43, 68], shares GPU servers among agents [70], prewarms sandboxes [74] and controls CPU and memory per tool call by declared intent [76]. Agent systems also run independent tool calls in parallel [30] and start a tool while the model is still decoding [69]. Speculative agent systems guess the agent’s next action and keep a guess only when the guess matches the action taken [71]. Build services schedule by a priority that users set [7]. CodeReel schedules the operations of a video build by what the agent is blocked on, within the build and across the agent’s think time. It admits the work of agents sharing a machine against one ledger of the machine’s cores and memory. The work ahead of CodeReel needs no rollback, since a frame stored under its key is exact for any later version that draws it.

References

  1. [1]Adobe. 2026. Memory and Storage in After Effects. https://helpx.adobe.com/after-effects/desktop/memory-storage-performance/memory-and-storage/memory-storage1.html. Section “The global performance cache”; accessed 2026-10-27.
  2. [2]Shubham Agarwal, Subrata Mitra, Sarthak Chakraborty, Srikrishna Karanam, Koyel Mukherjee, and Shiv Kumar Saini. 2024. Approximate Caching for Efficiently Serving Text-to-Image Diffusion Models. In USENIX Symposium on Networked Systems Design and Implementation (NSDI), 1173–1189.
  3. [3]Anthropic. 2026. Claude Code. https://code.claude.com/docs. Accessed 2026-11-10.
  4. [4]Anthropic. 2026. Models overview. https://platform.claude.com/docs/en/models/overview. Accessed 2026-11-10.
  5. [5]Xiangyu Bai, He Liang, Bishoy Galoaa, Utsav Nandi, Shayda Moezzi, Yuhang He, and Sarah Ostadabbas. 2026. MoReGen: Multi-Agent Motion-Reasoning Engine for Code-based Text-to-Video Synthesis. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR).arxiv.org/abs/2512.04221
  6. [6]Bazel. 2026. Remote Caching. Bazel documentation, https://bazel.build/remote/caching. Accessed 2026-11-16.
  7. [7]BuildBuddy. 2026. RBE Setup. BuildBuddy documentation, https://www.buildbuddy.io/docs/rbe-setup/. Accessed 2026-10-27.
  8. [8]Junhao Chen, Kevin Gao, Yuehan Cui, Mingze Sun, Mingjin Chen, Shaohui Wang, Xiaoxiao Long, Fei Ma, Qi Tian, Hao Zhao, and Ruqi Huang. 2026. LottieGPT: Tokenizing Vector Animation for Autoregressive Generation. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR).
  9. [9]Yanzhe Chen, Kevin Qinghong Lin, and Mike Zheng Shou. 2026. Code2Video: A Code-centric Paradigm for Educational Video Creation. In International Conference on Machine Learning (ICML) (Proceedings of Machine Learning Research, Vol. 306). 15370–15396.arxiv.org/abs/2510.01174
  10. [10]Zhenghan Chen, Zekai Shao, Xin Lin, Leting Cheng, and Siming Chen. 2026. Code2Video-Compass: A Comprehensive Benchmark for General-Purpose Code-Based Video Generation across T2V, I2V, and V2V. arXiv:2610.28416.arxiv.org/abs/2610.28416
  11. [11]Charlie Curtsinger and Daniel W. Barowy. 2022. Riker: Always-Correct and Fast Incremental Builds from Simple Specifications. In USENIX Annual Technical Conference (ATC). 885–898.arxiv.org/abs/2108.12469
  12. [12]DeepSeek-AI. 2026. DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence. Technical report.arxiv.org/abs/2606.19348
  13. [13]Matthew Dutson, Yin Li, and Mohit Gupta. 2023. Eventful Transformers: Leveraging Temporal Redundancy in Vision Transformers. In IEEE/CVF International Conference on Computer Vision (ICCV). 16911–16923. doi:10.1109/iccv51070.2023.01551
  14. [14]Bradley Efron. 1979. Bootstrap Methods: Another Look at the Jackknife. The Annals of Statistics 7, 1 (1979), 1–26. doi:10.1214/aos/1176344552DOI
  15. [15]Flutter. 2026. RenderRepaintBoundary and SceneBuilder.addRetained. Flutter API reference, https://api.flutter.dev. Accessed 2026-10-27.
  16. [16]Foundry. 2018. Op Hashing & Caching. NDK Developers Guide, https://learn.foundry.com/nuke/developers/112/ndkdevguide/advanced/hashing.html. Accessed 2026-10-27.
  17. [17]Fourier. 2026. A Video Framework for AI Agents and Developers. https://github.com/VoidFunOfficial/fourier. Render engine 5.0.0 (commit 86f6a5f); accessed 2026-10-27.
  18. [18]Jiaxin Ge, Zora Zhiruo Wang, Xuhui Zhou, Yi-Hao Peng, Sanjay Subramanian, Qinyue Tan, Maarten Sap, Alane Suhr, Daniel Fried, Graham Neubig, and Trevor Darrell. 2025. AutoPresent: Designing Structured Visuals from Scratch. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 2902–2911. doi:10.1109/cvpr52734.2025.00276DOI
  19. [19]Yunqi Gu, Ian Huang, Jiyheon Je, Guandao Yang, and Leonidas Guibas. 2025. BlenderGym: Benchmarking Foundational Model Systems for Graphics Editing. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 18574–18583. doi:10.1109/cvpr52734.2025.01731DOI
  20. [20]Gunin Gupta, Nirmit Arora, and Pavan Kalyan Tankala. 2026. Timeline-Bench: Evaluating Agents on Realistic Video-Editing Tasks, from Raw Footage to Final Cut. arXiv:2609.35143.arxiv.org/abs/2609.35143
  21. [21]Amirhossein Habibian, Davide Abati, Taco S. Cohen, and Babak Ehteshami Bejnordi. 2021. Skip-Convolutions for Efficient Video Processing. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 2695–2704. doi:10.1109/cvpr46437.2021.00272DOI
  22. [22]Matthew A. Hammer, Jana Dunfield, Kyle Headley, Nicholas Labich, Jeffrey S. Foster, Michael Hicks, and David Van Horn. 2015. Incremental Computation with Names. In Proceedings of the ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA). 748–766. doi:10.1145/2814270.2814305DOI
  23. [23]Matthew A. Hammer, Yit Phang Khoo, Michael Hicks, and Jeffrey S. Foster. 2014. Adaptom: Composable, Demand-Driven Incremental Computation. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). 156–166. doi:10.1145/2594291.2594324DOI
  24. [24]Sture Holm. 1979. A Simple Sequentially Rejective Multiple Test Procedure. Scandinavian Journal of Statistics 6, 2 (1979), 65–70.DOI
  25. [25]Ian Huang, Guandao Yang, and Leonidas Guibas. 2024. BlenderAlchemy: Editing 3D Graphics with Vision-Language Models. In European Conference on Computer Vision (ECCV). 297–314. doi:10.1007/978-3-031-73024-5_18DOI
  26. [26]HyperFrames. 2026. HyperFrames: Write HTML, Render Video, Built for Agents. https://github.com/heygen-com/hyperframes. Engine 0.8.150; accessed 2026-10-27.
  27. [27]Jetpack Compose. 2026. Lifecycle of Composables. Android Developers, https://developer.android.com/develop/ui/compose/lifecycle. Accessed 2026-11-16.
  28. [28]Kumara Kathapitiya, Haozhe Liu, Sen He, Ding Liu, Mengjia Li, Chenyang Zhang, Michael S. Ryoo, and Tian Xie. 2025. Adaptive Caching for Faster Video Generation with Diffusion Transformers. In IEEE/CVF International Conference on Computer Vision (ICCV). 15240–15252. doi:10.1109/iccv51701.2025.01414
  29. [29]kamishibai 2026. kamishibai: Turn Any Web Page into a Video. https://github.com/reearth/kamishibai. Version 0.13.0 (npm package, its edit benchmark run as shipped); accessed 2026-11-07.
  30. [30]Sehoon Kim, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. 2024. An LLM Compiler for Parallel Function Calling. In International Conference on Machine Learning (ICML). 24370–24391.
  31. [31]Akio Kodaira, Chengbeng Xu, Toshiki Hazama, Takanori Yoshimoto, Kohei Ohno, Shogo Mitsuhori, Soichi Sugano, Hanying Cho, Zhijian Liu, Masayoshi Tomizuka, and Kurt Keutzer. 2025. StreamDiffusion: A Pipeline-level Solution for Real-Time Interactive Generation. In IEEE/CVF International Conference on Computer Vision (ICCV). 12371–12380. doi:10.1109/iccv51701.2025.01150DOI
  32. [32]Max Ku, Cheuk Hei Chong, Jonathan Leung, Krish Shah, Alvin Yu, and Wenhu Chen. 2025. TheoremExplainerAgent: Towards Video-based Multimodal Explanations for LLM Theorem Understanding. In Annual Meeting of the Association for Computational Linguistics (ACL). 6663–6684. doi:10.18653/v1/2025.acl-long.332DOI
  33. [33]Cheuk Hang Lau, Zeyu Cao, Kevin Wong, Cheuk Y. Ng, Yao Lai, Haoran Wu, Nicholas D. Lane, Robert D. Mullins, Ilia Shumailov, and Yiren Zhao. 2026. Agent-PerfBench: A Benchmarking and Evaluation Suite for Inference Performance of Agentic LLMs. arXiv:2609.34683.
  34. [34]Muyang Li, Ji Lin, Chenlin Meng, Stefano Ermon, Song Han, and Jun-Yan Zhu. 2022. Efficient Spatially Sparse Inference for Conditional GANs and Diffusion Models. In Advances in Neural Information Processing Systems (NeurIPS). doi:10.5220/068431-2092
  35. [35]Peizheng Li, Xin Ai, Hanyuan Liu, Qiange Wang, and Yanfeng Zhang. 2026. RegionCache: Semantic-Aware Region Reuse for Efficient Multi-Turn Image Generation. In International Joint Conference on Artificial Intelligence (IJCAI). 1342–1350. doi:10.24963/ijcai.2026/150DOI
  36. [36]Yuejia Li, Ke He, Junheng Li, Shutong Chen, Jingkang Xia, Zhiyao Su, Junchi Zhang, and Mang Ye. 2026. See Before You Code: Learning Visual Priors for Spatially Aware Educational Animation Generation. arXiv:2605.15585.arxiv.org/abs/2605.15585
  37. [37]Wei Lin. 2026. Reels-SRI: Program-Level Self-Improvement for Code-Rendered Explainer Videos. arXiv:2610.14495.arxiv.org/abs/2610.14495
  38. [38]Feng Liu, Shiwei Zhang, Xiaofen Wang, Yujie Wei, Haonan Qiu, Yuzhong Zhao, Yingya Zhang, Qixiang Ye, and Fang Wan. 2025. Timestep Embedding Tells: It’s Time to Cache for Video Diffusion Model. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 7353–7363. doi:10.1109/cvpr52734.2025.00689
  39. [39]Jingwei Liu, Ling Yang, Hao Luo, Fan Wang, Hongyan Li, and Mengdi Wang. 2025. Preacher: Paper-to-Video Agentic System. In IEEE/CVF International Conference on Computer Vision (ICCV). 17129–17139. doi:10.1109/iccv51701.2025.01591DOI
  40. [40]Jiacheng Liu, Chang Zou, Yuanhui Lyu, Junjie Chen, and Linfeng Zhang. 2025. From Reusing to Forecasting: Accelerating Diffusion Models with TaylorSeers. In IEEE/CVF International Conference on Computer Vision (ICCV). 15853–15863. doi:10.1109/iccv51701.2025.01471
  41. [41]Tianyi Liu, Ye Lu, Linfeng Zhang, Chen Cai, Jianjun Gao, Yi Wang, Kim-Hui Yap, and Lap-Pui Chau. 2026. Accelerating Diffusion-based Video Editing via Heterogeneous Caching: Beyond Full Computing at Sampled Denoising Timestep. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 35800–35809.arxiv.org/abs/2603.24260
  42. [42]Vivian Liu, Rubaitat Habib Kazi, Li-Yi Wei, Matthew Fisher, Timothy Langlois, Seth Walker, and Lydia Chilton. 2025. LogoMotion: Visually-Grounded Code Synthesis for Creating and Editing Animation. In Proceedings of the CHI Conference on Human Factors in Computing Systems. doi:10.1145/3706598.3714155DOI
  43. [43]Yingpeng Liu, Yingqiang Zhang, Feifei Li, and Huanchen Zhang. 2026. Ask the Tool, Don’t Guess: Agent Tool Calls Hold Their Progress, and the Serving System Should Read It. arXiv:2609.18849.
  44. [44]Do Xuan Long, Xingchen Wan, Hootan Nakhost, Chen-Yu Lee, Tomas Pfister, and Sercan Ö. Arik. 2026. VISTA: A Test-Time Self-Improving Video Generation Agent. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 6021–6032.
  45. [45]Zhengyao Lyu, Chenyang Si, Junho Song, Zhenyu Yang, Yu Qiao, Ziwei Liu, and Kwan-Yee K. Wong. 2025. FasterCache: Training-Free Video Diffusion Model Acceleration with High Quality. In International Conference on Learning Representations (ICLR).
  46. [46]Jiajia Ma and Maneesh Agrawala. 2025. MoVer: Motion Verification for Motion Graphics Animations. ACM Transactions on Graphics 44, 4 (2025). doi:10.1145/3731209
  47. [47]Xinyin Ma, Gongfan Fang, and Xinchao Wang. 2024. DeepCache: Accelerating Diffusion Models for Free. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 15762–15772. doi:10.1109/cvpr52733.2024.01492DOI
  48. [48]Andrey Mokhov, Neil Mitchell, and Simon Peyton Jones. 2018. Build Systems à la Carte. Proceedings of the ACM on Programming Languages 2, ICFP (2018), 79:1–79:29. doi:10.1145/3236774DOI
  49. [49]Diego Nehab, Pedro V. Sander, Jason Lawrence, Natalya Tatarchuk, and John R. Isidoro. 2007. Accelerating Real-Time Shading with Reverse Reprojection Caching. In Graphics Hardware. 25–35. doi:10.2312/eggh.2007025-036
  50. [50]Yotam Nitzan, Zongze Wu, Richard Zhang, Eli Shechtman, Daniel Cohen-Or, Taesung Park, and Michaël Gharbi. 2024. Lazy Diffusion Transformer for Interactive Image Editing. In European Conference on Computer Vision (ECCV). doi:10.1007/978-3-031-72691-0_4DOI
  51. [51]OpenAI. 2026. Codex CLI. https://developers.openai.com/codex/cli. Accessed 2026-11-10.
  52. [52]OpenAI. 2026. Models. https://developers.openai.com/api/docs/models. Accessed 2026-11-10.
  53. [53]Zhaizeng Pan, Michael Wang, Chris Wu, Zhendong Hu, Xinwei Qiang, Zhongkai Yu, and Yufei Ding. 2026. AgentReplay: Token-Wise Trace Replay Is Essential for Fair Serving System Performance Benchmarking. arXiv:2609.32283.
  54. [54]Theodore Pamparkou, Vladislav Smirnov, Viktor Mazanov, Artem Vazhentsev, Preslav Nakov, Timothy Baldwin, and Artem Shelmanov. 2026. Bayesian Control for Coding Agents. arXiv:2606.24453.
  55. [55]Mathias Parger, Chengcheng Tang, Christopher D. Twigg, Cem Keskin, Robert Wang, and Markus Steinberger. 2022. DeltaCNN: End-to-End CNN Inference of Sparse Frame Differences in Videos. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 12497–12506. doi:10.1109/cvpr52688.2022.02157arxiv.org/abs/2203.03996
  56. [56]Jackson A. Prado Lima and Silvia Regina Vergilio. 2022. A Multi-Armed Bandit Approach for Test Case Prioritization in Continuous Integration Environments. IEEE Transactions on Software Engineering 48, 2 (2022), 453–465. doi:10.1109/tse.2020.2992428
  57. [57]React. 2026. memo. React API reference, https://react.dev/reference/react/memo. Accessed 2026-11-16.
  58. [58]Remotion. 2026. Flickering. Remotion documentation, https://www.remotion.dev/docs/flickering. Accessed 2026-10-27.
  59. [59]Remotion. 2026. Remotion: Make Videos Programmatically. https://www.remotion.dev. Version 4.0.538; accessed 2026-10-27.
  60. [60]Gregg Rothermel, Roland H. Untch, Chengyun Chu, and Mary Jean Harrold. 2001. Prioritizing Test Cases for Regression Testing. IEEE Transactions on Software Engineering 27, 10 (2001), 929–948. doi:10.1109/32.962562DOI
  61. [61]Bianca Schroeder, Adam W. Merchant, and Mor Harchol-Balter. 2006. Open Versus Closed: A Cautionary Tale. In Proceedings of the 3rd USENIX Symposium on Networked Systems Design and Implementation (NSDI). 239–252.
  62. [62]The Chromium Authors. 2026. Paint Result Caching, Blink Paint README. https://chromium.googlesource.com/chromium/src/+/main/third_party/blink/renderer/core/paint/README.md. Commit 64574fa; accessed 2026-10-27.
  63. [63]The Manim Community Developers. 2026. Manim – Mathematical Animation Framework. https://www.manim.community. Community Edition v0.22.0 (commit a6d5cc0); accessed 2026-10-27.
  64. [64]Bruce Walter, George Drettakis, and Steven Parker. 1999. Interactive Rendering using the Render Cache. In Rendering Techniques (Eurographics Workshop on Rendering). 19–30. doi:10.1007/978-3-7091-6809-7_3DOI
  65. [65]Zhou Wang, Alan C. Bovik, Hamid R. Sheikh, and Eero P. Simoncelli. 2004. Image Quality Assessment: From Error Visibility to Structural Similarity. IEEE Transactions on Image Processing 13, 4 (2004), 600–612. doi:10.1109/TIP.2003.819861DOI
  66. [66]WHATWG. 2026. HTML Living Standard: The canvas element. https://html.spec.whatwg.org/multipage/canvas.html. Accessed 2026-11-10.
  67. [67]Felix Wimbauer, Bichen Wu, Edgar Schoenfeld, Xiaoliang Dai, Ji Hou, Zijian He, Artsiom Sanakoyeu, Peizhao Zhang, Sam Tsai, Jonas Kohler, Christian Rupprecht, Daniel Cremers, Peter Vajda, and Jialiang Wang. 2024. Cache Me if You Can: Accelerating Diffusion Models through Block Caching. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 6211–6220. doi:10.1109/cvpr52733.2024.00594DOI
  68. [68]Tian Xia, Yi Xu, Hanchen Li, Zhifei Li, Xiaokun Chen, Hao Kang, Yifan Qiao, and Ion Stoica. 2026. Idleness is Relative: Exploiting Tool-Call Idle Windows for Offloading in Agentic Systems with MORI. arXiv:2606.00866.arxiv.org/abs/2606.00866
  69. [69]Yechen Xu, Xinhao Kong, Tingjun Chen, and Danyang Zhuo. 2024. Conveyor: Efficient Tool-aware LLM Serving with Tool Partial Execution. arXiv:2406.00059.arxiv.org/abs/2406.00059
  70. [70]Mingyan Yang, Guanjie Wang, Manqi Luo, Yifei Liu, Chen Chen, Han Zhao, Yu Feng, Quan Chen, and Minyi Guo. 2025. Justitia: Fair and Efficient Scheduling of Task-parallel LLM Agents with Selective Pampering. arXiv:2510.17015.
  71. [71]Naimeng Yu, Arnav Ahuja, Georgios Larkos, Yunan Lu, Kostis Kaffes, and Tianyi Peng. 2026. Speculative Actions: A Lossless Framework for Faster AI Agents. In International Conference on Learning Representations (ICLR).
  72. [72]Zihao Yu, Haoyang Li, Fangcheng Fu, Xupeng Miao, and Bin Cui. 2024. Accelerating Text-to-Image Editing via Cache-Enabled Sparse Diffusion Inference. In AAAI Conference on Artificial Intelligence. 16605–16613. doi:10.1609/aaai.v38i15.29599DOI
  73. [73]Yunzhi Zhang, Zishang Li, Matt Zhou, Shangzhe Wu, and Jiajun Wu. 2025. The Scene Language: Representing Scenes with Programs, Words, and Embeddings. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). doi:10.1109/cvpr52734.2025.02293DOI
  74. [74]Yihui Zhang, Tianyu Wu, Jinghao Wang, Xiaoyang Sun, Menghao Zhang, Cangzhou Yuan, Li Li, Chunming Hu, Albert Y. Zomaya, and Renyu Yang. 2026. SpecBox: Speculative Sandbox Scheduling for Efficient LLM Agent Serving. arXiv:2607.23933.arxiv.org/abs/2607.23933
  75. [75]Xuanlei Zhao, Xiaolong Jin, Kai Wang, and Yang You. 2025. Real-Time Video Generation with Pyramid Attention Broadcast. In International Conference on Learning Representations (ICLR).arxiv.org/abs/2408.12588
  76. [76]Yusheng Zheng, Jiakun Fan, Quanzhi Fu, Yiwei Yang, Wei Zhang, and Andi Quinn. 2026. AgentCGroup: Understanding and Controlling OS Resources of AI Agents. arXiv:2602.09345.arxiv.org/abs/2602.09345
  77. [77]Kan Zhu, Mathew Jacob, Chenxi Ma, Yi Pan, Stephanie Wang, Arvind Krishnamurthy, and Baris Kasikci. 2026. TraceLab: Characterizing Coding Agent Workloads for LLM Serving. arXiv:2606.30560.arxiv.org/abs/2606.30560
  78. [78]Zeyu Zhu, Kevin Qinghong Lin, and Mike Zheng Shou. 2025. Paper2Video: Automatic Video Generation from Scientific Papers. arXiv:2510.05096.arxiv.org/abs/2510.05096

Paper details

vlnc:W_r27gapqf
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

GPT-6.1, A coding agent

View statement
Looking for related papers…
Contents