motion-mosaic-editing

---
name: motion-mosaic-editing
description: >-
  Plan and execute Mosaic-style agentic AI motion-graphics video editing. Use
  when the user wants to add AI-generated motion graphics, animated captions,
  contextual overlays, or infographics to existing footage; build a reusable
  node/tile editing pipeline (rough cut → b-roll → captions → motion graphics →
  reframe → export); spec a text-prompt-driven motion-graphics brief; or
  reason about how an agentic video editor (like mosaic.so / Motion) is
  architected. Triggers: "motion graphics", "animate this video", "Mosaic-style
  editing", "agentic video editing", "auto-edit my footage", "kinetic captions",
  "reframe for TikTok/Reels", "motion mosaic".
---

# Motion Mosaic Editing

A methodology for producing **Mosaic-style agentic motion-graphics video
edits**: AI-generated typography, overlays, infographics, and kinetic captions
layered onto footage the user already has — orchestrated as a reusable,
inspectable pipeline rather than a one-shot prompt.

This skill encodes a model reverse-engineered from research into
[mosaic.so](https://mosaic.so) (the YC W25 agentic video editor and its
"Motion" product). It is a **methodology + workflow** skill — it teaches how to
plan and drive such an edit. It does not ship a rendering engine; see
`references/research-provenance.md` for exactly what is confirmed vs. inferred.

## Core mental model

Mosaic-style editing rests on five principles. Apply them in order.

1. **Edit, don't generate.** The primary input is *user-provided footage*.
   AI-generated clips (b-roll, avatars) are *supplementary*, never the spine of
   the video. Always start from real source material.
2. **Decompose into discrete operations ("Tiles").** Every edit is a chain of
   single-purpose steps (Rough Cut, B-Roll, Captions, Motion Graphics, Reframe,
   Music, Export…). Each step is independently inspectable, swappable, and
   re-runnable. Never collapse the whole job into one opaque instruction.
3. **A chain of Tiles is a reusable "Agent."** Once a chain works, it becomes a
   template you re-run on new footage and trigger by event/API. Design for
   reuse from the first edit.
4. **Understand the footage before editing it.** Decisions come from a *hybrid*
   of multimodal LLM analysis (Gemini-class long-context video understanding)
   and classical computer vision (saliency, audio energy, object detection,
   shot/emotion classification, "safe rectangle" placement zones).
5. **Keep an editable scene representation.** Motion graphics should be a
   structured, element-addressable scene — so a single title, color, or timing
   can be changed *without regenerating the whole shot*. Treat motion graphics
   as declarative scene specs, not baked pixels.

## When to use this skill

Use it when the user wants to: add motion graphics / animated overlays /
infographics to a video; auto-generate kinetic captions; reframe one video into
multiple aspect ratios; build a repeatable editing pipeline; A/B multiple edit
variants from one source; or design/critique an agentic-video-editing system.

## Workflow

### Step 1 — Intake & footage audit
Establish the deliverable (platform, aspect ratio, duration, tone, brand) and
audit the source footage: is there a talking-head/voiceover (drives caption +
overlay sync)? What is the resolution/length? What brand assets (fonts, colors,
logo) and *style reference* (a link to a video whose look should be matched)
exist? A style-reference video is the single strongest signal for look — capture
typography, palette, transitions, and pacing from it.

### Step 2 — Transcribe & analyze
Produce a timed transcript (speech-to-text) — it is the timeline backbone that
motion graphics and captions sync to. Run footage analysis: scene/shot
boundaries, on-screen subject location (for safe overlay placement), audio
energy (for pacing/emphasis), and emphasis points (claims, numbers, names worth
visualizing). See `references/pipeline-stages.md`.

### Step 3 — Design the Tile pipeline
Lay out the chain of operations as a graph. A canonical motion-graphics chain:

```
Source → Rough Cut → (B-Roll) → Captions → Motion Graphics → Reframe → Music → Export
```

Pick only the Tiles the deliverable needs. Each Tile has explicit inputs and a
single responsibility. See `references/architecture.md` for the full Tile
catalog and how to compose them.

### Step 4 — Spec the Motion Graphics brief
This is the heart of the skill. For each motion-graphic moment, write a brief
with: the text/data, the trigger timestamp (from the transcript), the layout
mode (**overlay** over the speaker vs. **fullscreen** cutaway for charts/data),
the style (inherited from the style reference / brand kit), and the density
(graphics per minute). Produce these as a structured, element-addressable spec
so individual elements can be tweaked later. Full method + a JSON spec template:
`references/motion-graphics-method.md`.

### Step 5 — Reframe, caption, score
Compute per-platform crops using subject saliency (keep the speaker/subject in
frame), not a static center crop. Style captions to social standards and sync to
speech timing, keeping them inside the safe rectangle. Add mood-matched music if
the brief calls for it. See `references/pipeline-stages.md`.

### Step 6 — Export & make reusable
Export to the target (social publish, or XML/EDL to Premiere / Final Cut /
DaVinci Resolve for full-res finishing — the agent layer produces decisions, the
NLE does the final render). Save the working chain as a reusable Agent template
and parameterize it for new footage.

## Implementing it for real

This skill is engine-agnostic by design. To actually render Mosaic-style motion
graphics yourself, the recommended architecture (consistent with principle 5) is
a **structured scene spec → deterministic renderer → encode** pipeline:

- **Scene spec**: an LLM emits a JSON scene graph (elements, positions, timing,
  easing, style tokens) — editable per element.
- **Render**: a programmatic/declarative renderer (e.g. Remotion/React, an
  SVG/CSS+headless-Chromium pipeline, or a Canvas/WebGL compositor) turns the
  spec into frames.
- **Encode**: FFmpeg muxes frames + audio to the delivery codec.

A diffusion/text-to-video model is the *wrong* tool for the graphics layer —
it cannot do clean element-level edits. Reserve generative video models for
supplementary b-roll only. Rationale and the full reasoning chain (including
what is verified vs. inferred about Mosaic) are in
`references/research-provenance.md`.

## Anti-patterns

- Treating it as text-to-video. It is an *editor*; bring footage.
- One mega-prompt. Decompose into Tiles or you lose inspectability and reuse.
- Center-crop reframing. Use subject saliency.
- Baking motion graphics as flat video. Keep an editable scene spec.
- Ignoring the transcript. It is the sync backbone for everything timed.

## References

- `references/architecture.md` — Tile catalog, Canvas/Agent model, API triggers.
- `references/motion-graphics-method.md` — the motion-graphics brief method + JSON scene-spec template.
- `references/pipeline-stages.md` — transcription, analysis, captions, reframe, models, export.
- `references/research-provenance.md` — confirmed facts, inferences, and the forensic findings behind this skill.