🐶 BDM Video — Multi-Agent Orchestration System

How a raw recording becomes a finished video through a producer agent, craft agents, independent QA reviewers, and human gates — layer by layer. Built for Bulldog Mindset; client-portable by design.

Producer (Tank — orchestrator) Editor (craft) Designer (craft) QA Reviewers (fresh, independent) Human gate (John) Shared state / storage

1. The orchestration topology

2. What each agent is made of (definition + governance layer)

The runtime flow above is driven by a substrate of files. Agents are generic engines; the client-specific part is data, not code. New client = new brand pack + docs, same agents.

Layer	What it is	Where
Agent definition files	Each agent (`tank`, `video-editor`, `designer`) has its own directory with `AGENTS.md` (rules + role), `IDENTITY.md`, `SOUL.md` (persona), `TOOLS.md`, `MEMORY.md`, `HB_SIGNAL.md` (heartbeat checks). This is who the agent is and how it behaves.	`agents/<name>/`
Skills / engines	The generic craft engine each agent runs: editor uses `video-edit`, designer uses `thumbnail-generate`. Client-agnostic “how to do the craft.”	`agents/<name>/skills/`
Brand pack	The client’s data: palette, fonts, music timing, overlay templates, asset paths, do/don’t — schema-validated so a typo fails loudly. Pinned per job (BDM locked at V9).	`brand-packs/bdm/`
Strategy & craft docs (governance)	The standards agents read at job start: `RUBRIC.md` (QA bar), `craft-lessons.md` (self-learning ledger), `PIPELINE.md` (the layered state machine), and the `strategy/` set — text-overlay, change-cadence, b-roll, soundbite-selection, end-screen, transcription, plus `DECISIONS.md` (John’s locked calls).	`pipelines/video/qa/`
Job manifest	Per-job state machine the agents read/write to know exactly what to do and what’s done — layers, gates, locks, owners, timestamps. The single source of truth.	`<job>/manifest.json`
Indexed libraries	Content-searchable media the editor queries: 602 b-roll clips + 1,567 photos, vision-tagged.	`_assets/*-library/`

Read order at a job: agent loads its own AGENTS.md → reads PIPELINE.md + strategy/ + craft-lessons.md + RUBRIC.md → loads the brand pack → reads the manifest for its layer brief → runs its skill/engine → writes outputs + status back to the manifest.

3. The layered pipeline (the key idea)

A pro editor works in locked layers and never restarts from zero. Each layer renders on top of the locked layer below it, gets QA'd, then John approves it. A later change re-renders only that layer and the ones after it.

Layer	What it adds	Owner	QA
L1 Story	A-roll radio cut + source soundbites (clip selection)	Editor	Reviewer A + John
L2 Punch-ins	Face-anchored editorial zooms	Editor	Reviewer A + John
L3 Text	Strategy-driven callouts (face-aware, restrained)	Editor + Designer copy	Reviewer B + John
L4 B-roll	Illustrative inserts from the indexed library	Editor	Reviewer A/B + John
L5 End screen	YouTube end-screen template	Editor + Designer	John
L6 Audio	Mix, loudness, final master	Editor	Reviewer A + John

4. How a layer actually moves

Dispatch — Tank sends the Editor a brief: { jobDir, lockedInput, layer, strategy docs }. The locked layer below is the exact input; nothing upstream changes.
Build + self-QC — Editor renders the layer, writes outputs to renders/layers/<NN>/, runs its own QC.
Independent QA — Tank spawns a fresh reviewer (never the session that built it): Reviewer A scores motion/cadence, Reviewer B scores design/brand/legibility, against a measurable rubric. FAIL → back to Editor with specifics.
Human gate — only a QA-passed layer reaches John. He approves (lock + next layer dispatches) or rejects with feedback (rework) — from Telegram or the dashboard buttons.
Lock — approval is written to the manifest; the layer is frozen and the next builds on it.

5. What makes it robust

Manifest is the single source of truth — every agent reads/writes job state there, not chat. Survives session resets and cross-session handoffs.
One render owner per layer (lockfile) — no double-renders.
Independent QA in fresh context — the reviewer never trusts the builder's self-report; it re-measures on the actual rendered master.
Self-learning — every human craft note becomes a permanent lesson + rubric check, so mistakes aren't repeated.
Generic engines + brand pack — the agents/skills are client-agnostic; only a data "brand pack" changes per client. New client = new pack, not new code.
Live observability — a command-center dashboard shows each layer's real status, what the agent is doing right now, and one-click approve/reject.

Bulldog Mindset video pipeline · Producer: Tank 🐶 · craft: video-editor + designer · orchestrated on OCPlatform. Diagram reflects the live system as of 2026-05-30.