Kino AI (YC S23) ships a collaborative video editor where Codex and Claude Code agents work on the same timeline as human editors. Not a chatbot that generates clips. Not a pipeline that hands off assets. A shared, mutable timeline where agents cut, splice, color-grade, and rotoscope while humans scrub, review, and tweak the same segments in real time.
The plumbing question is simple: what happens when an agent applies an edit to frame 1200 while a human is scrubbing that same segment?
The Concurrency Problem
Traditional video editors assume a single human operator. Collaborative tools like Frame.io or Wipster layer comments and approval workflows on top of immutable renders. Kino is different. Every edit, every motion graphic, every 3D scene, and every teammate comment is expressed as code (built on Remotion). Agents and humans both mutate that code.
The founder’s launch video workflow illustrates the collision surface:
- Five agents editing the timeline concurrently
- One agent rotoscoping for visual effects
- One LLM color-grading all media via LUT support
- Two humans making “tiny tweaks” to the same timeline
That’s at least seven concurrent writers to a single stateful artifact.
Code-First Architecture
Kino represents the entire timeline as code. This is not a metaphor. Every timeline item, every cut, every color correction, and every comment is a React component in Remotion. The editor is a WYSIWYG interface for React.
Why this matters for concurrency:
- Edits are text diffs, not binary blobs
- Operational transform (OT) or conflict-free replicated data types (CRDTs) can apply
- Version control primitives (branching, merging, rebasing) become possible
- Undo/redo is a stack of code patches, not a stack of binary states
The trade-off:
- You need a custom WYSIWYG editor for React (they built one)
- You need custom decoders for professional codecs (ProRes, DNxHD)
- You need to reconcile human drag-and-drop gestures with agent-generated code patches
Locking and Merge Strategies
Kino does not publish its concurrency primitives, but the problem space is well-defined. Here are the likely strategies and their trade-offs:
| Strategy | How It Works | When Agents Block | When Humans Block |
|---|---|---|---|
| Pessimistic locking | Lock timeline segments during edit | Agent waits for human to release segment | Human sees “locked by agent” indicator |
| Optimistic OT | Apply edits, resolve conflicts with operational transform | Never (conflicts resolved automatically) | Never (conflicts resolved automatically) |
| CRDT (Yjs/Automerge) | Commutative operations guarantee convergence | Never (all edits eventually converge) | Never (all edits eventually converge) |
| Approval queue | Agent edits go to a review branch | Always (human must approve) | Never (human edits are authoritative) |
The founder’s description (“5+ agents editing concurrently while my friend Donald had his swarm working a few minutes further down”) suggests optimistic concurrency with spatial partitioning. Agents and humans work on different timeline segments, reducing collision probability.
Agent Tool Boundaries
Agents interact with the timeline via tool calls. The API surface likely includes:
// Hypothetical Kino agent tool schema
interface KinoTools {
// Timeline mutation
cut(timelineId: string, frameStart: number, frameEnd: number): void;
splice(timelineId: string, clipId: string, position: number): void;
applyLUT(clipId: string, lutPath: string): void;
// Asset retrieval
searchFootage(query: string, embedding?: number[]): Clip[];
getTranscript(clipId: string): Transcript;
// Review and annotation
addComment(timelineId: string, frame: number, text: string): void;
resolveComment(commentId: string): void;
}
Security boundaries:
- Agents cannot delete footage (only remove from timeline)
- Agents cannot publish review links (human-only action)
- Agents cannot modify other agents’ comments (append-only log)
Failure modes:
- Agent applies a cut while human is rendering that segment (render invalidated)
- Agent references a clip that human just deleted (dangling reference)
- Agent generates invalid React code (syntax error breaks timeline)
State Management and Undo
Because the timeline is code, undo/redo is a patch stack. But agents complicate this:
- Human undoes an agent’s color correction
- Agent re-applies the correction (it doesn’t know it was undone)
- Human undoes again
- Loop
Likely solution: Agent edits are tagged with an agent ID and timestamp. Undo removes the patch and adds the agent ID to a blocklist for that operation type. The agent sees the blocklist on its next tool call and skips the operation.
// Hypothetical undo metadata
interface UndoEntry {
patchId: string;
agentId?: string;
timestamp: number;
operation: "cut" | "splice" | "applyLUT" | "addComment";
blocklist?: string[]; // Agent IDs that should not retry this operation
}
Observability and Conflict Detection
Real-time collaboration requires visibility into who is doing what. Kino shows teammate cursors and which part of the timeline they’re watching. For agents, the equivalent is:
- Which segment is the agent currently editing?
- What tool call is in flight?
- What is the agent’s current objective?
Likely implementation:
- Agents publish a “working on segment X” heartbeat
- Human UI shows agent activity as a colored overlay on the timeline
- Conflicts trigger a notification (not a block)
Deployment Shape
Kino is a hybrid architecture:
- Local scrubbing: Custom decoders let you drag a 250GB ProRes clip and scrub immediately
- Cloud proxy: Low-res proxy uploaded for teammates and cloud inference
- Collaborative state: Real-time sync (likely WebSocket or WebRTC)
- Agent execution: Cloud-based (agents need access to uploaded proxies)
The bottleneck: Uploading a 250GB ProRes file. Even at 1 Gbps, that’s 33 minutes. The local scrubbing is a UX win, but agents can’t start work until the proxy is ready.
Technical Verdict
Use Kino’s approach when:
- You need agents to collaborate with humans on the same mutable artifact (not just generate and hand off)
- Your domain has a code representation (video via Remotion, CAD via OpenSCAD, music via Sonic Pi)
- You can tolerate eventual consistency (agents and humans converge, but not instantly)
Avoid when:
- You need strict serialization (financial transactions, medical records)
- Your artifact has no code representation (freeform illustration, audio waveforms)
- You cannot afford merge conflicts (agents must never overwrite human work)
The real innovation is not the video editor. It’s the concurrency model for agent-human collaboration on mutable, stateful media. The same primitives (code-first representation, optimistic OT, spatial partitioning) apply to CAD, music production, game development, and any domain where agents and humans co-create.