How do you keep AI agents synchronized across episodes of a video series?

Keep AI agents synchronized across episodes with one centrally locked context: one project per series, one showrunner agent holding the locked show bible in a shared notebook, and a director agent per episode assigned its own notebook page. Any mid-series change gets updated once in the central context, and every agent inherits it automatically.

Set up the hierarchy before you generate anything: one project per series, one showrunner agent for the whole show, and one director agent per episode. invideo is an agentic video creation tool, so this crew structure is something you build directly inside it — the invideo agent holds the shared context while sub-agents execute episodes.

1. Load the showrunner agent with the show bible. The showrunner agent is the executive producer of the series: it holds the tone, visual language, characters, world, and series arc in a notebook that every other agent references. Treat the show bible as the single source of truth, and lock scripts before production — locked scripts put agents into execution mode instead of open-ended interpretation.

2. Spin up a director agent per episode, each with its own notebook page. Assign a notebook to every episode director — skipping this assignment is the setup error that breaks the pipeline, because generations from different episodes blend into one undifferentiated pool. With per-episode notebooks everything stays compartmentalized: your post team isn't digging through 100 generations to find one shot from episode 4. In traditional studio terms, this is assigning an AD to every episode.

3. Lock shared assets before any episode generates video. Generate all character sheets (front, side, three-quarter angles plus facial close-ups) and all location reference sheets in parallel in a single pass, then lock the finals and store them as shared context assets. Lock reference sheets before generating frames, not after — and every later iteration (costume change, lighting shift, new angle) starts from a locked base image, never from scratch. This is what keeps episode 8's protagonist identical to episode 1's.

4. Propagate mid-series changes through the central context, once. If a character picks up a scar or a haircut mid-series, update it one time in the central context — every director agent inherits the change for all subsequent episodes automatically. Never patch individual episodes by hand; per-episode fixes drift out of sync immediately.

5. Synchronize your human team the same way. Each team member runs their own agent instance loaded with the identical locked show bible, episodic scripts, character sheets, and location references, so no one works off a different version. Multiple producer agents can run in parallel against that same central context, which is how a 3-person crew shipped a 10-episode series (episodes of roughly 1.5–2 minutes) in 3 days at about $1,000 per episode — a pipeline roughly 5X faster than a standard microdrama production.

If you come from a general multi-agent AI background, this is architecturally the same idea as MCP-based context sharing and session kernels: a persistent shared memory layer that child agents read from and inherit updates through, rather than each agent carrying its own drifting copy of the world. The structure also scales — an agency managing multiple series runs one project per series, one showrunner agent per project, and episode directors inside each.

Watch some of these to see what works for you:

Mid-series change like a scar or a haircut? Update the context once, the Agent remembers for every episode.

— invideo's creative team