Back to Blog
Galen Guan

onetake Deep Dive: Programmatic Motion, Boundary Carry, and Agent Oracle Verification

Anyone who has tried creating product launch films or motion demos using AI tools inevitably hits a frustrating brick wall: the resulting video feels entirely loose and disconnected. Title card, fade out, app UI shot, fade out, feature card, fade out, and a hard cut to the company logo. Each shot might look decent in isolation, but strung together, the whole piece reads like a monotonous slideshow. Scenes merely replace one another rather than growing out of each other, completely lacking audiovisual continuity.

In our work on Generative Canvas Agent Architecture and Video Remake Pipeline Stability, we identified cross-shot continuity as the central hurdle in multi-shot generation. In late September 2026, an open-source project surfaced on GitHub with a remarkably fresh design philosophy: onetake by Patrick (GitHub: feitangyuan/onetake, 538 stars, 40 forks). Packaged as an Agent Skill for Claude Code and Codex, onetake introduces a radical proposition against conventional video generation: "Motion films that never cut to the next slide — every beat grows out of the one before."

Crucially, onetake does not stop at design manifestos. It provides a complete deterministic motion engine governed by pure time functions $f(t)$, vector UI reconstruction without screen recording, shutter motion blur, and an automated acceptance oracle that rejects flawed cuts before a human ever has to watch them.

This article dissects onetake's architecture, underlying mathematics, and design trade-offs, concluding with practical architectural recommendations for modern generative AI video canvas systems.

1. onetake's Architecture: Pure Functions of Time to Deterministic Delivery

Unlike Remotion or HyperFrames which rely on complex component runtimes, onetake opts for radical simplicity and deterministic reproducibility: the entire film is authored inside a single HTML file driven by a pure mathematical time function $f(t)$.

onetake Architecture & Execution Pipeline

1.1 The Core Foundation: Deterministic Timeline $f(t)$ and Seek Contract

The foundational rule of onetake is the complete elimination of temporal state accumulation and randomness. In motion synthesis, non-deterministic random functions and incremental physics steps are notorious culprits behind frame drifting and rendering artifacts.

Under onetake's protocol:

  • The entire composition exposes a single entry point: window.__seek(t);
  • Every visual transform (DOM matrix, Canvas 2D call) must be a pure, stateless function of time $t$;
  • Physical spring dynamics and soft-body simulations (Verlet / Jelly / Sim) are pre-integrated once at 240 Hz on page load and sampled via discrete time interpolation;
  • Seeking to the exact timestamp $t$ twice produces bit-for-bit identical frames, which is the foundational prerequisite for high-precision shutter motion blur.

1.2 The Move Library: lib/motion.js and $t_{80}$ Metrics

Many animators and developers default to generic ease-in-out cubic beziers. This results in soft, symmetrical transitions that strip motion of impact, rhythm, and tension.

onetake ships lib/motion.js, containing 39 validated motion primitives across curves, entrances, carries, contact physics, camera rigs, and fluid grounds. The central benchmark used to characterize motion is $t_{80}$: $$\text{The share of duration spent before 80% of the travel distance is covered}$$

  • Low $t_{80}$ (e.g. 0.23 with expoOut): Rapid explosive snap followed by an extended settle. This snap-and-settle curve is the essential visual DNA of high-end consumer tech launch films.
  • High $t_{80}$ (e.g. 0.71 with smoothstep): Symmetrical, slow travel that reads as a lethargic website scroll.
  • Underdamped Springs: $$x(t) = 1 - e^{-\zeta \omega t} \left(\cos(\omega_d t) + \frac{\zeta \omega}{\omega_d} \sin(\omega_d t)\right), \quad \zeta < 1$$ Simulates realistic collision bounces and squash-from-velocity without hardcoded, brittle animation constants.

1.3 Rebuilding the Real UI in Vector HTML

Screen recordings are the conventional path for software feature demos, but they suffer from fundamental flaws: screen resolutions cap camera zoom, close-up details become blurry, UI lag is baked into the video, and sensitive account data can leak.

onetake's lib/ui_kit.js enforces code-level UI reconstruction:

  • The user provides static screenshots of the interaction path;
  • The Agent reconstructs the interface using absolute HTML/CSS within the reference screenshot's native pixel coordinates;
  • The reconstructed UI is projected onto a 3D camera plane. When the camera flies in for a $2.5\times$ zoom on a dropdown menu, typography and vector borders remain mathematically sharp;
  • UI state transitions are modeled as pure functions set(state).

1.4 True Shutter Motion Blur

Rendering fast movements in headless Chromium without blur creates harsh strobing and visual stuttering. Standard CSS filter: blur() applies uniform Gaussian diffusion, failing to reproduce directional motion smearing.

onetake's scripts/render.py implements an optical 180° open-shutter multi-sample blur:

  • The render script queries window.__motion(t0, t1) to determine the peak pixel velocity across the frame;
  • When speed exceeds 80 px/frame, multiple sub-frame seeks are executed across the shutter interval;
  • Sub-samples are averaged in linear light space before color conversion;
  • Parallelized across multi-worker Chromium instances, producing cinematic motion trails that match physical cinema cameras.

2. The Core Breakthrough: Boundary Carry & Oracle Verification

Why do most AI-generated promotional videos feel like a slideshow? onetake's diagnosis is clear: scenes merely replace each other. Beat A dies, and Beat B appears out of nowhere.

2.1 The Philosophy of Boundary Carry

onetake designates the seam between two beats as the highest-priority creative unit. Across every beat boundary, an existing visual entity must survive and transform into the next beat:

  • Container Morphing (morphRect): A search input bar does not fade out; it expands outward into the desktop app window, which subsequently reflows into a mobile phone interface;
  • Geometric Extension: An input box collapses into a thin line, shoots across the canvas like a beam of light, and becomes the foundational gridline of the next scene;
  • Camera Penetration (zoomThrough): Rather than cutting, the camera rushes forward, penetrates through a feature card's surface texture, and emerges into the next scene;
  • Gather and Seal (gather -> seal): Floating UI elements gather inward under magnetic pull, with a blinking cursor drawing the final brand lockup in a single stroke.

In onetake, scenes are tethered by physical and geometric causality, not sequential time slots.

2.2 The Automated Acceptance Oracle

In multimodal agent development, human review is the most expensive bottleneck. onetake couples probe.py with verify_promo.py to create an automated acceptance oracle that evaluates compositions against quantitative standards before human inspection:

onetake Acceptance Oracle Verification Matrix

python3 scripts/verify_promo.py film.mp4 --comp comp.html --ref ref.mp4 --shots 0,1.6,3.0,4.8,7.0,9.6,12.1

The Six Quantitative Verification Legs:

Leg Metric & Threshold Rationale
1. Cadence Shot length coefficient of variation $CV = \frac{\sigma(L)}{\mu(L)} \ge 0.25$ Eliminates metronomic cuts. Requires shot lengths to vary by $\ge 4\times$ (e.g. 0.25s rapid typography hits next to a 2.5s hold).
2. Rest Dead-still frames $\ge 25%$ and quiet period $\ge 1.0\text{ s}$ Evaluated via 320px downsampled pixel diffs. High-energy bursts only land when contrasted with deliberate stillness.
3. Continuity (Carry Score) $\text{Carry Score} \ge 0.5$ ($<0.5$ fails immediately) probe.py scans 0.4s boundary windows. Elements that survive and morph earn 1.0; anchored frames earn 0.5; bare cuts earn 0.
4. Curves & Blur Velocity $> 80\text{ px/frame}$ requires shutter blur Flags visual strobing and motion tearing when high-velocity elements lack multi-sample motion blur.
5. Framing Declared IDs in window.__meta.inFrame must not leave frame Prevents spring-driven camera whips from accidentally flinging the primary subject out of view.
6. Audio Integrity Peak $\le -3\text{ dBFS}$, 0 clipped samples Sounds are positioned in a single convolution reverb room, with music ducking under visual impact hits.

In onetake's development history, an early cut of Pocket Weather had crisp rhythm but scored 0.00 in Carry Score because scenes swapped cleanly. The cut was rejected until v3, where every beat grew out of the previous one, achieving a Carry Score of 0.75.

2.3 Multi-Language Time Warping: UIK.timeWarp

Localizing video content across languages is notoriously difficult. A 3-second English voiceover line might require 4.8 seconds in Japanese. Traditional workflows either stretch clips awkwardly or fork the video project, creating maintenance overhead.

onetake solves this with UIK.timeWarp:

  • On a single master HTML composition, visual anchor knots are attached to semantic word timestamps obtained from Kokoro TTS and faster-whisper;
  • Querying comp.html?lang=ja activates the language layer;
  • The time-warp algorithm applies monotonic spline warping to adjust visual hold durations between beats while preserving movement velocities;
  • One single composition supports dozens of languages without code forks.

3. Multi-Dimensional Evaluation: Strengths, Weaknesses, and Trade-offs

A comprehensive analysis of onetake's codebase, scripts, and sample case breakdowns yields the following profile:

┌────────────────────────────────────────────────────────────────────────┐
│                      onetake Capability Profile                         │
├────────────────────────────────┬───────────────────────────────────────┤
│ Strengths                      │ Weaknesses & Constraints              │
├────────────────────────────────┼───────────────────────────────────────┤
│ • High-end launch-film aesthetics│ • Limited to UI/tech/kinetic demos   │
│ • 100% deterministic, 0 hallucinations │ • Heavy headless Chromium render load │
│ • Rigorous automated acceptance oracle│ • PolyForm Noncommercial (No commercial use) │
│ • Non-linear TimeWarp localization │ • High mathematical authoring friction │
└────────────────────────────────┴───────────────────────────────────────┘

3.1 Strengths

  1. Solves the AI Slideshow Problem at the Root: By replacing scene swaps with camera-driven geometric carries, the resulting videos rival bespoke commercial motion design (e.g., Apple launch keynotes, Linear product teasers).
  2. Deterministic Reproducibility: Unlike probabilistic diffusion models where identical seeds can still drift across software versions, vector code ensures that every frame renders consistently.
  3. Exemplary Agent Harness Engineering: The protocol encoded in SKILL.md maps prior production failures into hard rules, while automated test scripts verify criteria before human involvement.

3.2 Constraints & Challenges

  1. Narrow Domain Scope: onetake is fundamentally a programmatic motion graphics engine. It cannot generate realistic human faces, cinematic natural landscapes, or narrative drama scenes; it does not replace diffusion video models for photorealistic cinema.
  2. Headless Browser Rendering Overhead: Rendering 180° motion blur requires multiple Chromium frame captures per output frame. Generating a 15-second 60fps 4K video requires thousands of full-resolution headless screenshots, imposing significant CPU and RAM demands.
  3. Strict Non-Commercial Licensing: The project is licensed under PolyForm Noncommercial 1.0.0, explicitly prohibiting commercial use. Commercial products cannot incorporate onetake's scripts or libraries directly; they must absorb its architectural principles and implement clean-room solutions.

4. Architectural Lessons for Generative AI Video Canvases

In our earlier discussion on Generative Canvas Agent Architecture, a canvas Copilot is structured as a Canvas-Assembly Agent. Its responsibility is composing runnable DAGs of AI nodes (Nodes + Edges + Parameters) on the canvas, rather than rendering pixels directly in chat.

Comparing onetake with the current state of generative video canvases reveals key parallels and opportunities for improvement:

Generative Video Canvas Architecture Proposal: Hybrid Programmatic Motion & Diffusion Video Pipeline

Diagnostic: Pain Points in Current Generative Canvases

  1. Continuity Relies Heavily on Prompt Locks: In modern generative canvases, prompt specifications frequently define rules for [Identity Lock], [Lens Lock], and Prop Ledgers. However, video diffusion models (Seedance, Wan, Kling) frequently exhibit motion vector drift across cut boundaries. Prompt constraints alone cannot enforce geometric momentum across shots.
  2. Weakness in Product Demos and Kinetic Typography: When users ask a canvas agent for "a 15-second product demo video" or "a dynamic title sequence," the agent defaults to Image-to-Video (I2V) or Recut workflows. Diffusion models frequently distort interface text, warp button shapes, and hallucinate layout details, resulting in wasted GPU credits.
  3. Shot Breakdown Lacks Rhythmic Metrics: When planning shot durations, canvas agents frequently tend to divide timelines evenly (e.g., dividing 20s into four identical 5s shots), missing the rhythmic variety that dynamic video requires.

Actionable Implementation Proposals

Proposal 1: Formalize Boundary Carry Primitives in Continuity Protocols

We should formalize boundary transition mechanics into the continuity protocol:

  • Motion Vector Carry: Require downstream prompts to explicitly inherit upstream velocity vectors (e.g., if shot 1 tracks rapidly toward a door, shot 2 must explicitly open with that identical momentum);
  • Physical Carry Anchors: Encourage explicit object transformations across shot transitions, avoiding disconnected cuts.

Proposal 2: Introduce Cadence & Rest Checks to Plan Validation

Before an agent outputs a canvas plan for user execution, run an automated pre-check on the shot plan:

  • Calculate the shot length variation coefficient $CV = \frac{\sigma(L)}{\mu(L)}$. If $CV < 0.25$, flag the plan for adjustment to avoid monotonous pacing;
  • Verify that the plan includes at least one low-motion or rest shot to establish visual breathing room.

Proposal 3: Support Hybrid Canvas Execution: Code Motion + Diffusion Nodes

Generative canvases can combine generative models with deterministic motion tools:

  • Dual-Track Division: Photorealistic human performances, cinematic environments, and complex textures are handled by Diffusion Video nodes; sharp UI interactions, typography, and brand lockups are handled by programmatic HTML/SVG motion nodes;
  • Layered Compositing: Composite layers together on the canvas, combining crisp vector precision with generative visual depth while lowering GPU compute costs.

Proposal 4: Implement Word-Level TimeWarp for Multi-Language Delivery

For marketing teams localizing video assets across languages, we can adopt UIK.timeWarp's approach. By tying visual transitions to word-level timestamps, canvas plans can adapt to different voiceover lengths without requiring manual reconstruction of the underlying animation timing.

5. Conclusion

onetake demonstrates that not every motion design problem should be delegated to end-to-end diffusion models.

For product demos, feature showcases, and typography where geometric precision and momentum continuity are paramount, programmatic time functions $f(t)$ paired with automated oracle verification deliver superior reliability compared to generative pipelines.

For modern generative video canvases, incorporating boundary carry principles, rhythm validation, and programmatic motion primitives into the canvas assembly workflow represents a practical path toward production-grade AI video creation.

References

  1. Patrick — feitangyuan/onetake GitHub Repository (September 2026)
  2. onetake Protocol — SKILL.md Specifications and Hard Rules
  3. onetake Reference — Continuous Camera & Rhythm Reference (rhythm.md)
  4. onetake Guide — Product Demos Without a Screen Recording (product-demo.md)
  5. PolyForm Project — PolyForm Noncommercial License 1.0.0
  6. Galen Guan — Generative Canvas Agent Architecture: From Cognitive Settling to DAG Scheduling (September 2026)
  7. Galen Guan — AI Video Control Techniques Compared: From Camera Motion to Multimodal Guidance (August 2026)