One showrunner agent holds the show bible — tone, characters, world, canon. Per episode you spin up a director agent with its own isolated notebook page for execution. The showrunner is the source of truth; directors execute. This mirrors AD-per-episode staffing in traditional studios and lets a 3-person crew ship 10 episodes in one run.
An AI drama series runs on a two-tier agent crew: one showrunner agent holds the show bible — tone, characters, world rules, canon — and a separate director agent is spun up per episode, each with its own isolated notebook page for execution. The showrunner is the single source of truth; the directors execute against it. Built inside the invideo agent, this structure mirrors AD-per-episode staffing in a traditional studio, and it is how a 3-person crew shipped a 10-episode microdrama series in one production run.
The AI Drama Series Hierarchy in One Sentence
A hierarchical multi-agent crew for an AI drama series means one showrunner agent holds the master show bible, tone, characters, and world context, while individual director agents are created per episode, each with its own notebook page for shot breakdown, generation, and iteration. If you are evaluating an AI drama generator workflow, this is the architecture that keeps ten episodes consistent without one person policing every generation.
The split of responsibilities is strict:
| Responsibility | Showrunner agent | Director agent (per episode) |
|---|---|---|
| Show bible, tone, visual language | Owns | Reads |
| Character and location sheets | Holds locked finals | Pulls, never modifies |
| Series canon and world rules | Single source of truth | Inherits |
| Episode script | Stores locked version | Executes against it |
| Shot breakdown and generation plan | — | Generates and runs |
| Iteration on individual shots | — | Owns, inside its own notebook |
The traditional-studio analogy holds exactly: "If you're running a studio, it's the equivalent of assigning an AD to every episode." The showrunner never generates episode footage; the directors never touch canon.
Setting up the crew follows a fixed order:
- Create one project for the series — the whole show lives in one project, nothing else does.
- Create the showrunner agent and load it with the show bible: tone rules, character descriptions, world details, series arc.
- Lock the pre-production assets — character sheets and location references — into the showrunner's central context.
- Lock the episode scripts. Locked scripts put agents into execution mode; unlocked scripts invite drift.
- Spin up one director agent per episode, and assign each one its own notebook page before it generates anything.
- Run the directors — sequentially or in parallel — each pulling from the same central context.
What Lives on the Showrunner
The showrunner agent is the executive producer of the series: as invideo's creative team puts it, "It holds the big picture, the tone, the visual language, the character, world, everything." Concretely, four asset classes live there and nowhere else:
- The show bible — premise, tone rules, world logic, series arc, and any canon that must survive across episodes. "Show Bible = single source of truth. Locked scripts = execution mode."
- Locked character sheets — every character rendered from front, side, and three-quarter angles plus facial close-ups, generated in parallel for the whole cast in a single pre-production pass, then locked as finals. Lock the reference sheets before generating any frames, not after — every later iteration (a costume change, a lighting shift, a new angle) starts from these locked base images, never from scratch. The full workflow for locking cast and location sheets is covered separately.
- Location reference sheets — one per recurring set, built in the same parallel pass as the cast.
- Locked episode scripts — the version every director executes against. No director works from a draft.
Centralizing these assets is what makes mid-series changes cheap: give a character a scar or a haircut in episode 4, update the central context once, and every subsequent director agent inherits the change automatically. "Update the context once, the Agent remembers for every episode."
What Each Director Agent Does Per Episode
Each director agent runs exactly one episode — a director agent explained in one line is an execution agent that reads its episode's locked script, understands the pacing and beats, and auto-generates a shot-by-shot breakdown that becomes that episode's shooting schedule. You don't build the schedule manually; the director agent derives it from the script, and you approve or adjust it before generation starts.
From the breakdown, the director agent executes generation and iteration against the locked context it pulls from the showrunner: locked character sheets for casting, location sheets for sets, tone rules for look. Generate 3–4 options per shot so your editor has real coverage to cut from rather than a single take per beat. Where model choice matters — say, Seedance 2.0 reference-to-video for shots that need to hold a previous shot's spatial layout — the invideo agent routes each shot to the right model; every current video model runs inside invideo, so the director agents never leave the project.
Two setup rules are non-negotiable. First, assign a notebook page to every director agent before it generates anything — skipping the notebook assignment is a documented setup error, and it sits near the top of the common multi-agent mistakes list. "This is important that you create a notebook with every episode director." Second, keep episodes compartmentalized: one director per episode means every generation is filed where it belongs. "Everything stays compartmentalized. Your post team isn't digging through 100 generations to find one shot from episode 4." At series scale — each episode running roughly 1.5 to 2 minutes with multiple options per shot — that filing discipline is the difference between a searchable project and an undifferentiated pile of clips.
Running Directors in Parallel
Director agents don't have to run one at a time: multiple producer and director agents can work simultaneously, each pulling from the same centrally uploaded show bible, scripts, and character sheets. Because the context is centrally locked, parallel agents can't diverge — they are all reading the same locked finals, and any update to the central context propagates to every agent automatically. The mechanics of keeping agents synchronized across episodes come down to that one rule: agents inherit context, they never own copies of it.
The same locked context makes the structure collaborative. Each team member runs their own agent instance loaded with the identical show bible, episodic scripts, and reference sheets — "Every team member uploads the same locked show bible and episodic scripts into their agent. No one's working of a different version." How to split a series across people is covered in team collaboration on one series. The invideo mobile and iPad apps let you monitor and continue agent work while parallel directors run, which compounds the speed gain on complex projects.
Parallelism is what makes the volume math work. Microdrama is a throughput business — "For a Microdrama studio, the game isn't only a great script. It's shipping enough of them, fast enough, to find your winner as soon as possible." With directors running in parallel off one showrunner, a documented production shipped 10 episodes in 3 days with a 3-person crew at $1,000 per episode — a pipeline roughly 5X faster than a standard microdrama production. How that throughput translates into a release cadence is the subject of our microdrama volume strategy.
How Agencies Scale Across Shows and Clients
The hierarchy extends cleanly from one series to a slate: one project per series, one showrunner agent for every project, and episode directors inside each project. That is the exact structural formula, and it means an agency running microdramas for three clients maintains three projects, three showrunners, and as many director agents as there are episodes in flight — with zero cross-contamination between shows, because no agent in project A can see project B's canon, cast, or scripts.
Each project's crew panel shows the full hierarchy at a glance — the showrunner and every episode director in that series — so a producer can audit any show's state without opening individual episodes. Client-side changes follow the same single-update rule as mid-series character changes: update one show bible, and every director in that project inherits it, while every other client's series stays untouched. The operational detail — billing separation, hand-offs between account teams, onboarding a new series — is covered in how agencies manage multiple series.
FAQ
What is a showrunner agent?
A showrunner agent is the top-level agent in a multi-agent AI drama series crew. It holds the show bible, tone rules, visual language, locked character and location sheets, and series canon — the single source of truth every episode-level agent pulls from. It sets and protects the show's context; it does not generate episode footage itself.
What is a director agent?
A director agent is an episode-level execution agent. It reads that episode's locked script, auto-generates a shot-by-shot breakdown that serves as the shooting schedule, then runs generation and iteration against the locked context inherited from the showrunner. Each director agent gets its own notebook page so its generations stay compartmentalized to its episode.
Do you need a separate director agent per episode?
Yes. One director per episode is what keeps generations filed by episode instead of pooled into one undifferentiated project — your post team shouldn't dig through hundreds of generations to find one shot from episode 4. It also matches traditional staffing: it's the equivalent of assigning an AD to every episode.
Can multiple director agents run in parallel?
Yes. Multiple director agents work simultaneously, all pulling from the same centrally locked show bible, scripts, and character sheets, so parallel execution can't cause drift. Running directors in parallel is how a 3-person crew shipped 10 episodes in 3 days.
How do agencies manage multiple series with agent crews?
One project per series, one showrunner agent per project, and episode director agents inside each project. Projects are isolated, so canon, cast, and scripts never leak between clients, and a context update for one show propagates only to that show's directors.