CoAnimator · Competitive research · 2026-08-12

Timelines for Agents
a 9-product teardown

How Remotion, Diffusion Studio, ChatCut, HyperFrames, Cardboard, Palmier, Overlap, MidRender and Motion model, edit and let AI manipulate the timeline — ranked, compared against CoAnimator's timeline today, and distilled into a build plan. The short version: the market has converged on five agent-timeline patterns, CoAnimator ships none of them yet, and no competitor combines a real timeline with an HTML animation stage — that lane is open.

9 products studied 4 codebases read (Remotion · Diffusion · Palmier · HyperFrames) 5 research agents in parallel docs · repos · demo transcripts · APIs

00:01 · The five findings that matter

TL;DR

Agent edits = normal edits

Five products land AI edits as ordinary undoable operations on the shared undo stack — no modal "AI result" screen. ChatCut applies each plan step live; Overlap's AI passes are "a normal Studio timeline change"; Palmier makes it doctrine. This is now table stakes.

Agents get eyes

Three teams independently shipped agent vision: the agent renders frames of its own edit and self-corrects before reporting done (Palmier inspect_timeline, Cardboard v0.34, Diffusion's node capture doctrine). Convergent evolution — not coincidence.

Checkpoints beat undo

Cardboard and Motion anchor restorable checkpoints to chat messages ("roll back to that message"); ChatCut snapshots whole timelines; Diffusion has diff-restoring checkpoints at every level. Multi-step agent sessions need coarser rollback than Cmd+Z.

MCP is the new API

Palmier (44 intent tools), Overlap (full surface mirror), ChatCut, MidRender (metered per tool call) and Motion all ship MCP servers. Palmier's twist: every mutation returns a delta so the agent patches its context instead of re-reading. CoAnimator has no tool surface at all.

The open lane

Nobody combines a real timeline with an HTML animation stage. HyperFrames (the closest twin) lacks waveforms and ripple; Palmier edits footage, not animation; Motion has no timeline. CoAnimator's timeline + __kcControl stage + waveforms is already unique — it needs the agent contract on top.

00:02 · Three philosophies of time

The landscape

Every product answers the same question — where does the truth of the edit live? — one of three ways. CoAnimator belongs to the second family, which is where the most defensible engineering is happening.

1 · NLE + director agent

ChatCutCardboardPalmier

A conventional multi-track timeline is the truth; the agent is a colleague that edits it — plan first, then per-step operations the human can undo individually. Deep manual surfaces: JKL, ripple, keyframes, NLE XML export.

2 · Same-files engines

RemotionDiffusionHyperFramesMidRenderCoAnimator

Code or markup is the truth; the GUI and the agent edit the same source and the editor hot-reloads. Remotion goes furthest: every GUI drag is an AST codemod written back into your .tsx.

3 · No timeline, by design

Motion.soOverlap

Chat and pipelines are the truth. Motion has literally no timeline ("no timeline to learn"); Overlap's editor is deliberately thin — its transcript and keep-range API do the editing. Fast to ship, but neither can nudge anything by 500 ms.

00:03 · One dossier per product · TL = timeline depth · AG = agent contract (0–5)

How each one does it

Palmier

#1 overall
open sourcemacOS nativeYC S24NLE + agent
TL
4.5
AG
5.0

Swift NLE with frame-integer clips on typed tracks, per-property keyframe lanes, linked A/V groups, nested timelines, multicam, ripple-delete of ranges. The agent surface is the deepest studied: a local MCP server with ~44 filmmaker-intent tools where every mutation returns a delta (changed clips + compressed shift rules), undo is itself a tool, and inspect_timeline renders composited frames so the model can see its edit. Skills are SKILL.md playbooks; a meta-skill reverse-engineers a finished timeline into a reusable playbook.

Steal Mutation deltas · frames-for-timeline/seconds-for-source contract · one-intent-one-undo shared with the agent.
Gap macOS 26 Apple-Silicon only; generative backend closed; pricing unsettled.

Diffusion Studio

#2
editor OSSbrowser + electronYC F24same-files
TL
4.0
AG
4.5

An ECS engine (frames @30) under a canvas-rendered timeline with filmstrips, waveforms and keyframe rows. The most rigorous specs in the field: timing split into two questions (start/end placement vs sourceIn/sourceOut window, invariant enforced); scrub-then-settle seeking (paint the covering GOP keyframe instantly, exact-seek on rest); flash-free splits that hand the primed decoder to the right half; a fully-specified Premiere-style overwrite drop model. Agent contract is the self-describing dapi CLI — patches go through the same setters as the UI, same undo, plus perception commands (filmstrip, waveform, transcribe, capture).

Steal Two-question timing model · scrub-then-settle · frame-space snapping spec · CLI-with-perception as agent contract.
Gap No ripple anywhere; speed exists for humans but not agents; core engine source no longer public.

ChatCut

#3
closedbrowser + desktopNLE + agent
TL
4.5
AG
3.5

The best transcript↔timeline fusion: word-level dual-engine timestamps; deleting words splits at word boundaries and ripples — with the sharpest scope rule studied: "only the track you're editing ripples; other tracks never shift." Silence is compressed, not deleted (>3s→200ms, >1s→600ms, user slider). Around it, a real NLE: V/N/B modes, JKL, Q/W trim-to-playhead, on-clip fade handles and volume lines, six keyboard preset schemes (Premiere/Resolve/FCP/CapCut), version snapshots that restore through the undo stack, FCP7 XML export. The agent presents a plan, then applies each step as an ordinary undoable edit while the timeline stays visible.

Steal Per-track ripple scope · silence compression · keyboard preset schemes · plan-then-apply as undoable steps.
Gap Timeline JSON / MCP tool schema unpublished; no diff-preview for agent edits.

Remotion

#4
open sourcereactsame-filesdev-first
TL
3.5
AG
4.5

No timeline document exists — time structure is the React tree, and the Studio derives tracks from it at runtime. Its "read-only timeline" reputation is obsolete: clips drag, trim (left-edge trim writes from+duration+trimBefore together, rate-compensated), split, duplicate, reorder, keyframe — and every GUI edit is an AST codemod written into your source, so human drags and agent text-edits compose in one file with server-side undo. Editability is a static-analysis contract: non-analyzable code grays out with a reason. Ships 12 agent skills, editor plugins, a system prompt, and per-clip "Copy context for agents."

Steal Three-value trim math · editability-status-with-reason · bidirectional agent contract · worker waveforms/filmstrips · anchor-preserving zoom.
Gap No ripple, no markers, no per-track mute/solo; the drag-drop editor timeline for products is a paid add-on.

Cardboard

#5
closedbrowserYC W26NLE + agent
TL
4.0
AG
3.0

"Cursor for video editing": a real browser NLE (ripple toggle R, razor, snapping, keyframe lanes, beat-synced multi-clip edits, custom keybindings, Premiere XML + Resolve handoff with timecode preserved) driven by a "Director" chat with model picker. Three ideas worth copying: chat checkpoints that roll timeline state back to any message; interactive pickers mid-run (audition music before the agent proceeds); and agent vision self-review of rendered frames (v0.34). Frame-pinned comments on share links.

Steal Chat checkpoints · mid-run pickers · per-track "remove gaps".
Gap No API/MCP, internal format fully closed — power stays inside their app.

HyperFrames (HeyGen)

#6
open sourcehtml→videosame-files32.5k ★
TL
3.5
AG
3.5

CoAnimator's architectural twin: clips are DOM elements with data-start/data-duration/data-track-index, rendered deterministically frame-by-frame — and its free local Studio has a real timeline: drag-retime, cross-track drag, edge trim, razor, snap toggle, keyframe diamonds with bezier easing, pointer gesture recording (R), music beat-analysis markers, word-level caption lane with a sidecar overrides file. Agent story is identical to yours: agent and Studio edit the same files, and every Studio dead-end emits an "Ask Agent" prompt pre-filled with project context.

Steal "Ask Agent" prefilled prompts · gesture recording · beat markers · variables for batch renders.
Gap No audio waveforms anywhere; no ripple/close-gap; caption timing edits don't survive reload.

Overlap

#7
closedworkflow pipelineclipping
TL
2.0
AG
4.0

A node-graph clipping factory (iHeartMedia at 150M views) whose editor is deliberately thin — but whose public API leaks the cleanest edit representation studied: a clip is keep-ranges over one source (segments: [{startSeconds, endSeconds}], validated non-overlapping) plus word objects {index, start, end, speaker, isDeleted} patchable by text, time-range, or index. Cuts snap to sentence boundaries with ±5s slack kept for later trimming. Three verbs per transcript selection — Cut / Mute / Edit-caption — and an MCP server mirroring the whole human surface.

Steal Keep-ranges as trim representation · sentence-snap + slack · cut/mute/edit-caption verb split.
Gap No trim handles, razor, or waveforms documented; no NLE export; "not built for detailed editing."

MidRender

#8
closedmotion graphicsYC S23 · solosame-files
TL
2.0
AG
3.0

By Revideo's own creator — and he made the move that matters: migrated from TypeScript scenes to a declarative XML format specifically because agents co-edit documents more reliably than imperative code. Tween/scene timeline (labels show from→to values), keyframes + easing, cloud render queue, an embeddable live scene runtime, and MCP + CLI as the product — MCP tool calls are the metered billing unit (100/week free, 1M/week on $20 Pro).

Steal Published schema for the scene document · tween values in track labels · MCP metering as pricing.
Gap No clip trim/split (tween model, not footage); docs gated; team of one.

Motion (motion.so)

#9
closedchat-firstno timeline
TL
0.5
AG
1.5

The anti-timeline pole, done well enough to matter: video → scenes → live editable elements, "no regenerating entire scenes, no hallucinated artifacts," Cursor-style chat checkpoints. But time itself is untouchable — API duration is a bucket (<10s…1-5min), the only API edit primitive is a whole-video followup, and no scrub/trim/retime surface exists anywhere. PH users still called element editing "the unlock" — proof of demand for regeneration-free editing, and proof nobody in this cluster can nudge a scene 500 ms.

Steal Brand-from-URL design ingestion · duration buckets at the brief stage · asset provenance with time ranges.
Gap Everything temporal. Also: no third party has ever reviewed the editor hands-on.

00:04 · 24 capabilities × 10 products

Capability matrix

ships it partial / constrained absent (verified or strongly implied) ? unknown — no evidence either way
CapabilityCoAnimatorPalmierDiffusionChatCutRemotionHyperFr.CardboardOverlapMidRenderMotion
Navigation
Scrub / playhead
JKL shuttle??
In/out playback range??
Zoom (anchor-preserving)?
Clip operations
Trim handles (both edges)
Ripple (trim / delete / close-gap)
Split / razor
Drag re-arrange?
Snapping (with guides)??
Multi-select + group drag???
Timeline visuals & physics
Audio waveforms?
Video filmstrips????
Keyframes on the timeline?
Markers / beat markers
Transitions as first-class objects?
Clip speed / playback rate
Fades / volume drawn on the clip
Text ↔ time
Transcript-linked video editing
Word-level caption objects
Agent contract
Agent edits on the shared undo stack??
Checkpoints / versions?
Agent vision (renders own edit)
Mutation deltas returned to agent
Semantic tool surface (MCP / CLI)
NLE interchange (XML / EDL out)

CoAnimator column from docs/timeline.md + Timeline.tsx (v0.6.12). "?" is honest absence of evidence, mostly in closed products — treat unknowns as unknowns, not as gaps. CoAnimator's ◐ on ripple = ripple trim exists (Shift-drag); ripple delete doesn't. ◐ on tools = coa render exists; no edit tools.

00:05 · Two axes, then one list

Ranking

One score hides the story, so two axes: how deep the human timeline goes, and how mature the agent contract is. The upper-right is where the market is heading; nobody fully owns it yet.

01.252.53.755 02.55 TIMELINE DEPTH → AGENT CONTRACT → THE OPEN LANE Palmier Diffusion ChatCut Remotion Cardboard HyperFrames Overlap MidRender Motion CoAnimator TARGET

Best to rest, one line each

Palmier

The only product strong on both axes: a genuine NLE and the best agent contract in the field (44 intent tools, deltas, vision, undo-as-tool, skills). Its ceiling is reach — macOS-26-only.

Diffusion Studio

Engineering rigor nobody else matches — the timing model, seek architecture, snap and overwrite specs are publishable. Agent CLI with perception. Docked for zero ripple and a human-only speed control.

ChatCut

The transcript↔timeline fusion is the best single interaction studied, inside a real NLE with pro keyboard culture. Closed schema keeps it at #3.

Remotion

The deepest ecosystem and the smartest hybrid idea (GUI edits = AST codemods; editability as a static-analysis contract). Dev-only by nature; the product timeline is a paid add-on.

Cardboard

Checkpoints, mid-run pickers and agent vision are the right calls; a real NLE underneath. Everything is sealed inside the app — no API, no format, no MCP.

HyperFrames

Your twin, executed well: real Studio timeline over HTML-as-truth, gesture record, beat markers. No waveforms and no ripple keep it mid-table.

Overlap

Editor is intentionally shallow; the API is the star — keep-ranges, three-mode transcript patching, MCP mirror. A pipeline product, not an editor.

MidRender

Right instincts (XML-for-agents, MCP metering, embeds) at one-founder scale with gated docs. Watch it.

Motion

Proves demand for regeneration-free element editing — and that a no-timeline product can't serve anyone who cares about 500 ms.

CoAnimator today

Timeline depth ~3 (ripple trim, extend-to-fill, ghosts, snapping, waveforms already ship) — mid-table and ahead of its twin on audio. Agent contract ~2: hot-reload file editing is real but raw; no tools, deltas, vision, or checkpoints. The plan below moves both axes.

00:06 · Where the field independently agrees

Convergent patterns

When competitors who never talk to each other ship the same mechanism, treat it as a discovered law of the category, not a fashion.

Agent edits are ordinary, undoable edits

No modal AI-result screens. The agent's step lands on the same undo stack as a human drag, named after the action.

ChatCutOverlapPalmierDiffusionRemotionCardboard

The agent verifies with its own eyes

Render sampled frames of the edited timeline; look; self-correct; only then report done. Cheapest trust-builder there is.

PalmierCardboardDiffusion

Checkpoints anchored to conversation

Undo is for humans at 1x; agents need message-level rollback. Snapshot per agent turn; restore is itself undoable.

CardboardMotionChatCutDiffusion

Placement ≠ source window

Where a clip sits vs which part of the source plays, held by an invariant — and trims that write all coupled values in one operation.

DiffusionRemotionOverlapPalmier

An intent-level tool surface, usually MCP

Tools speak filmmaker ("split this at the beat"), not internals. Self-describing; same setters as the UI; deltas > re-reads.

PalmierOverlapChatCutMidRenderDiffusion CLI

Text is a timeline handle

Word-level timestamps make the transcript an edit surface: click to seek, delete to ripple, compress silences instead of cutting them.

ChatCutOverlapPalmierHyperFrames

00:07 · What suits CoAnimator — ranked, sourced, sized

The CoAnimator plan

The strategy the evidence supports: don't chase Motion's chat-only model, and don't rebuild Premiere. CoAnimator already owns the rare combination — a real timeline over a deterministic HTML stage, with waveforms, hot-reload, and an agent that edits the same files. Phase 1 makes the timeline feel professional, Phase 2 gives humans and agents shared semantics, Phase 3 builds the contract that turns "Claude edits JSON" into the best agent surface in the category.

PHASE 1

Make it feel pro

small, high-leverage, mostly UI
Full transport vocabulary: JKL shuttle, I/O in-out range with draggable ruler markers, A/E jumps, frame-step

The single loudest "this is a real editor" signal; playback loops inside the range. CoAnimator has none of it today.

Remotion · HyperFrames · ChatCutS
Left-edge trim writes start + duration + trimIn together, rate-compensated

Port Remotion's ~30-line tested pure function; kills the classic trim-desync bug family before playbackRate ships.

RemotionS
Anchor-preserving zoom

Capture the frame under the cursor before changing px/s, restore scroll after. Small function, huge feel win.

RemotionS
Ripple delete + per-track ripple scope + "remove gaps"

Ripple trim already exists; add ripple delete with ChatCut's rule made visible: only the track you're editing ripples.

ChatCut · Cardboard · PalmierM
On-clip audio fades + volume line

Drag fade handles and a volume line on the clip body — no inspector round-trip. Fills a ◐ in the matrix.

ChatCut · Palmier · DiffusionM
Beat markers on music clips

Analyze BGM once, draw beat ticks, add them to the snap targets. Three competitors ship it; pairs perfectly with the ElevenLabs music workflow.

HyperFrames · Cardboard · PalmierM
Keyboard preset schemes

Premiere / Resolve / FCP / CapCut bindings + custom. Cheap courtship of NLE muscle memory.

ChatCutS
PHASE 2

Semantics humans and agents share

model + engine work
Adopt the two-question timing doc: placement vs source window, invariant stated

Rewrite the timeline doc around start/end vs sourceIn/sourceOut ("trimming the source is not the same as moving the clip"). Costs a day; upgrades every future agent edit.

DiffusionS
Keep-ranges on clips, compiled to splits internally

Accept segments: [{start, end}] per clip in timeline JSON — the easiest trim representation for an LLM to emit and validate.

OverlapM
Clip playbackRate — exposed to humans and agents on day one

Diffusion's own gap is the warning: they shipped speed for the inspector but not the agent surface. Don't repeat it.

Diffusion (counter-example)M
Keyframes for volume + opacity, clip-local time

Keyframe time zeroed at clip start so animation travels when the clip moves — the mistake everyone else already fixed.

Diffusion · Remotion · PalmierL
First-class transitions: timing/presentation split, overlap arithmetic

Between-clip entries {duration, easing, presentation}; adjacent clips overlap by the duration; validate clip length. Steal springTiming.

Remotion · DiffusionL
Editability status with reasons

Template-generated or animation-locked clips gray out with "why" instead of failing silently — the best hybrid code+GUI pattern found.

RemotionM
Silence tools: removeSilences() primitive + compression defaults

One-call VO cleanup returning resulting clips; compress pauses (>1s→600ms, >3s→200ms, slider) rather than hard-cutting them.

Diffusion · ChatCutM
PHASE 3

The agent contract — the moat

this is where the category is won
MCP server over the existing IPC: filmmaker-intent tools, same mutations and undo as the UI

Palmier's doctrine verbatim: tools express intent, one coherent action per call, structured receipts, never silently clamp. CoAnimator's IPC surface already exists — this is a wrapper, not a rewrite.

Palmier · Overlap · DiffusionL
Mutation deltas in the read-tool's vocabulary

Every mutating tool returns changed clips + compressed shift rules + removed ids, so an agent runs long edit sessions without re-reading the file. Nobody else but Palmier has this — it's the fastest thing to copy that's genuinely rare.

PalmierM
inspect_timeline: render N sampled frames via the headless renderer

CoAnimator already renders headlessly for exports — a thin tool over it gives Claude eyes on its own edit. Three competitors converged here.

Palmier · Cardboard · DiffusionS
Chat checkpoints: snapshot timelines/<id>.json per agent message

File-based timelines make this nearly free; "roll back to that message" becomes one copy. Restore lands on the undo stack, ChatCut-style.

Cardboard · Motion · ChatCutS
Undo as a tool + one-intent-one-undo, shared between UI and agent

Frame agent edits as "undoable and effectively free"; failed calls never create undo entries.

PalmierM
"Copy context for agents" + "Ask agent" on every clip

Clip name + file + JSON path to clipboard; Studio dead-ends emit a prefilled prompt. The cheapest GUI↔agent bridge in the study.

Remotion · HyperFramesS
Transcript panel bound to VO clips

Word-level timestamps already exist in the voice pipeline: click word = seek; delete words = split at boundaries + per-track ripple; strikethrough as history.

ChatCut · OverlapL
create-skill-from-timeline

Distill a finished project into a reusable playbook — a perfect fit for the template system that already exists.

PalmierM

The one-sentence strategy: keep the timeline (Phase 1 makes it feel professional), formalize its semantics so both species of editor share them (Phase 2), then ship the Palmier-grade contract — tools, deltas, vision, checkpoints — over the file-based architecture you already have (Phase 3). That end state — real timeline + waveforms + deterministic HTML stage + best-in-class agent contract — is a combination no product in this study offers.