# Your own director

> Your AI assistant looks at the frames and writes the video plan itself; Slicer applies its director rules to the plan on the server. Free in Slicer.

Source: https://docs.slicer.media/en/mcp/own-director/

An AI montage is two jobs: understanding the material (what is said, what is shown, which takes are best) and editing the video (the script, the cuts, the editor tools). Your AI assistant connected to Slicer over MCP can do both: it looks at the frames and writes the video plan itself. Slicer applies the rules of its AI director to the plan on our server, builds the video and answers with what it corrected itself and what the assistant should fix. So the video is edited on your assistant's subscription and limits — and in Slicer it's free.

## Why

-   **Free in Slicer.** The director brief, frames, accepting the plan, edits, style and export spend no tokens.
-   **The assistant is the director.** The assistant decides on the story, the order of thoughts, the best takes and what to show: it looks at the frames itself and tells Slicer what it saw.
-   **Our director's rules stay on the server.** The assistant doesn't get the rules of the Slicer AI director: they are applied to the plan when the assistant submits it. The answer brings fixes and issues, so the video comes out clean even if the model slipped somewhere.
-   **The video is your project.** The result shows up in the app's editor right away: polish it by hand, ask the assistant to fix details, or export it.

| Free | Paid — Slicer's AI features |
| --- | --- |
| the director brief (`get_director_brief`), frames (`get_frames`), accepting the plan (`submit_director_plan`) | [captions from speech](https://docs.slicer.media/en/mcp/tools/#transcribe) — `transcribe_speech`, at cost per minute of sound |
| an Edit it myself project (`create_project`), edits (`edit_project`), style (`set_style`), export and publishing (`export_video`) |     |

Speech is recognised by the Slicer server: that's how the video gets words with ids, by which speech is cut. It's the only paid step, and the assistant starts it only after you agree to the price ([Price confirmation](https://docs.slicer.media/en/mcp/costs/#at-cost)). If there's no speech in the material, everything is free. Our own [AI montage](https://docs.slicer.media/en/mcp/examples/#ai-director) stays available too — for those who don't have an assistant of their own.

## How it works

### 1. Upload and project

The assistant uploads the files (`create_upload_link` or `import_from_url`) and creates a project with `create_project` in `manual` mode — like **Edit it myself** in the app, for free. Within seconds the project becomes a draft.

### 2. Speech

If the materials contain speech, the assistant calls `transcribe_speech` without `confirmCost`, tells you the price and, after your yes, recognises the speech; progress — `get_transcribe_jobs`.

### 3. Director brief

`get_director_brief` returns the material (`material`): the sources, speech by word ids, pauses, `[RETAKE …]` takes and your wishes — plus a few general tips (`guide`), the plan schema (`planSchema`) and the schema of observations from the frames (`scenesSchema`). The brief has no rules of the Slicer AI director. If you named the video type, pace, effects or length, the assistant passes them here — they are saved to the project, and Slicer takes them into account when it accepts the plan.

### 4. Frames and observations

The brief has no frame analysis either: the assistant looks for itself — `get_frames` returns frames of a source as images (how to look economically). What it saw — where the author talks, where an action is shown, what isn't fit for the video — the assistant writes down as observations.

### 5. Plan

The assistant thinks the story through like an editor — meaning, order, best takes, showing the action, the ending — and sends the plan and the observations with `submit_director_plan` together with the `rev` from the brief.

### 6. Fixes and issues

Slicer applies its director rules to the plan (what happens to the plan), builds the video and saves it as a new revision. The answer contains what Slicer corrected itself, issues with the plan and the video as text. If there are issues, the assistant fixes the plan and submits it again (plan → issues → fixed plan).

### 7. Result

When there are no issues left, the assistant compares the video with its idea, fixes details with `edit_project` and `set_style`, sends you a link to the project and asks whether to export the video.

### Director brief (your own director)

`tool get_director_brief`

- **Scopes:** `projects:write`
- **MCP:** safe to retry

Free. Lets YOU direct the video with Slicer: returns the material (speech by word ids w<ID>, pauses, \[RETAKE …\] marks, wishes), the sources list, general tips, planSchema and scenesSchema. There is no visual analysis: look at the footage with get\_frames. Then send the plan and what you saw with submit\_director\_plan — Slicer applies its director rules there and tells you what to fix. Optional settings (video type, pace, effects, length, hook, plaques, emoji, camera moves) are saved to the project. If the video has speech, recognise it first (transcribe\_speech).

#### Parameters

| Field | Type | Description |
| --- | --- | --- |
| `projectId` _(required)_ | `integer` | Project id — ≥ 1 |
| `mode` | `string` | Video type — `auto` · `talking` · `story` · `product` · `aesthetic` |
| `pace` | `string` | — `calm` · `balanced` · `dynamic` |
| `effects` | `string` | — `off` · `light` · `bold` |
| `targetDurationSec` | `integer \| null` | Target length, s; null — up to the director (≤ 90 s) — 10–180 |
| `hook` | `boolean` |     |
| `plaques` | `boolean` |     |
| `emoji` | `boolean` |     |
| `cameraMotion` | `boolean` |     |

#### Example prompt

> “Edit this video yourself, like the Slicer director”

### Look at the footage

`tool get_frames`

- **Scopes:** `projects:read`
- **MCP:** read-only

Free. Frames of a source as images (up to 16 per call, 512 px): at given seconds (times) or evenly over from…to (count, default 8). Start with a few frames per source, then look closer where the action, the product or the result is. A photo source returns its single image.

#### Parameters

| Field | Type | Description |
| --- | --- | --- |
| `projectId` _(required)_ | `integer` | Project id — ≥ 1 |
| `sourceIndex` _(required)_ | `integer` |     |
| `times` | `number[]` | Seconds of the source — 1–16 |
| `from` | `number` |     |
| `to` | `number` |     |
| `count` | `integer` | — 1–16 |

#### Example prompt

> “Show me what happens in the second clip”

### Apply your director plan

`tool submit_director_plan`

- **Scopes:** `projects:write`

Free. Turns your plan (planSchema) into the video: Slicer applies its director rules on the server — word boundaries, retakes, footage placed by your scenes (scenesSchema), restraint, length — and saves a new revision (visible in the editor). The answer has "fixes" (what Slicer corrected), "issues" (what you should fix — then submit again) and the resulting video as text. Polish details with edit\_project, then export\_video. mediaCards must be empty (a generated picture is paid) — use own photos via update\_card.

#### Parameters

| Field | Type | Description |
| --- | --- | --- |
| `projectId` _(required)_ | `integer` | Project id — ≥ 1 |
| `rev` _(required)_ | `integer` | Document revision from get\_transcript; edits are rejected if the video changed since |
| `plan` _(required)_ | `Record<string, object>` | The plan object in planSchema |
| `scenes` | `Record<string, object>[]` | What you saw in the frames, in scenesSchema — 0–400 |

#### Example prompt

> “Here is my plan — build the video”

## How the assistant looks at the footage

`get_frames` returns up to 16 frames per call, 512 pixels on the longer side, right in the tool result — as images the model sees itself. Frames can be taken at given seconds of the source (`times`) or evenly over a range (`from`, `to`, `count`, 8 frames over the whole source by default). A photo returns its single image; audio has no frames.

Every frame uses your assistant's limits, so it's worth looking economically — the brief and the `direct_reel` prompt suggest the same:

1.  **An overview first** — 6–8 frames evenly over every video, one call per source.
2.  **Then closer where it matters** — around the moments the speech refers to ("look", "here's the result"), around actions and product shots.
3.  **Observations along the way** — where the author talks and where an action is shown, how interesting the frame is, which parts aren't fit for the video (dark or blurred frames, end cards). The assistant sends them along with the plan.

For 1–5 minutes of material, 30–120 frames are usually enough.

## Observations from the frames

Our director gets the material marked up by the frame analysis: where the author talks to camera, where an action is shown, where there's b-roll. With your own director, the assistant makes this markup — from the frames it has seen — and sends it along with the plan in the `scenes` field, following `scenesSchema` from the brief. Each observation is a part of one source:

| Field | Meaning |
| --- | --- |
| `sourceIndex` | the source number, required |
| `start`, `end` | the start and end of the part in seconds of the source, required |
| `kind` | what's in the frame, required: `talking_head` — the author talks to camera and shows nothing; `demo` — an action, a product or a result is shown, even while the author talks; `people` — people in the frame; `screen` — a screen or a screen recording; `broll` — b-roll; `unusable` — not fit for the video: dark, blurred, an end card |
| `interest` | how interesting the part is for the viewer, from 1 to 5 |
| `description` | what is visible, briefly — up to 200 characters |

scenes:

```json
[
  { "sourceIndex": 0, "start": 0, "end": 14.5, "kind": "talking_head", "interest": 3, "description": "The barista talks at the counter" },
  { "sourceIndex": 0, "start": 14.5, "end": 21, "kind": "demo", "interest": 5, "description": "Draws a heart on a latte" },
  { "sourceIndex": 1, "start": 0, "end": 9, "kind": "broll", "interest": 4, "description": "Guests with cups by the window" }
]
```

Slicer places the footage by the observations: from the pieces the plan requested it removes the talking head and the parts marked `unusable`, and for a b-roll source the plan skipped it picks the most interesting suitable part itself. The observations also serve the plan check: the `footage_is_talking_head`, `unusable_footage` and `nothing_shown` issues come only from them.

Observations are optional, but without them Slicer doesn't know what's in the frames: the author silently looking into the camera or a poor shot may end up in the footage. One plan takes up to 400 observations; times outside the source are clamped to its edges, and observations with an unknown source or kind are skipped.

## What Slicer does with the plan

The assistant's plan is data: Slicer executes nothing from it. It checks the plan with the schema, applies the rules of its AI director to it — the same rules our director works by — and only then builds the video. The rules stay on the server: the assistant sees only their result.

-   **Schema.** A plan that doesn't match the schema is rejected with `bad_plan` and a list of the first errors — the assistant fixes it and sends it again; a plan without fragments — `empty_plan`.
-   **Speech by words.** Speech fragments are set only by word ids: cut points land on word and pause boundaries, and filler words inside speech are cut.
-   **Footage by observations.** Pieces without speech are trimmed against the source and the observations; a b-roll source the plan skipped is placed into the video by Slicer itself.
-   **Restrained editing.** Speech plays at natural speed, editor tools are rare accents: Slicer removes extra tool settings itself and says so in the fixes.
-   **Length.** The video fits the length from the settings: if the plan is longer, the least important fragments go first.
-   **Revision.** If the video was changed in the editor meanwhile, the plan is rejected with `409 stale_document` — the assistant re-reads the project and sends the plan with the new `rev`.

What Slicer doesn't decide for the assistant — where to end a thought, which take is better, what to show — comes back as issues.

## Plan → issues → fixed plan

An accepted plan replaces the whole video right away and is saved as a new revision — even if it has issues. The title, description and hashtags from the plan are saved for publishing. The answer of `submit_director_plan`:

-   `rev` — the new revision: the assistant sends the next plan or edits with it;
-   `durationSec`, `planSegments`, `fragments` — the video's duration, the number of plan and video fragments;
-   `fixes` — what Slicer corrected itself;
-   `issues` — issues: a code (`code`), the plan fragment number from zero (`segment`, if the issue is about a fragment) and what to fix (`message`);
-   `video` — the video as text, as in `get_transcript`.

The `fixes` and `message` texts are in English: the model reads them. All issue codes — [Plan issues](https://docs.slicer.media/en/api/editing/#director-issues).

submit_director_plan response (abridged):

```json
{
  "rev": 4,
  "durationSec": 29.6,
  "planSegments": 7,
  "fragments": 8,
  "fixes": ["Filler words are cut automatically inside kept speech."],
  "issues": [
    { "code": "cuts_thought", "segment": 2, "message": "Segment 2 stops in the middle of a sentence (\"…we steam milk…\"): end it where the thought ends." }
  ],
  "video": "…"
}
```

### 1. First plan

The assistant sends the plan and the observations with the `rev` from the brief. Slicer builds the video and answers with fixes and issues.

### 2. Going through the issues

Each issue says what's wrong and where: `cuts_thought` on fragment 2 — extend the fragment to the end of the thought, `two_takes` — keep one take of the two, `footage_is_talking_head` — take a shot where the action is visible. The corrections from `fixes` are already in the video — no need to repeat them.

### 3. Fixed plan

The assistant sends the whole plan again — with the new `rev` from the answer: with the old one the plan is rejected with `409 stale_document`. The new plan again replaces the whole video.

### 4. While there are issues

The loop repeats until `issues` is empty. After that, small things are easier to fix with `edit_project` operations; send a new plan only when the story itself changes: it also replaces the edits made after the previous plan.

## Limitations

-   **Framing is centred.** Observations don't say where the face is in the frame, so the frame is centred. The assistant, which has seen the frames, fixes it with the `set_framing` operation ([Frame, mask, speed](https://docs.slicer.media/en/api/editing/#ops-frame)).
-   **Media cards only with your own photos.** A card picture from a description is drawn by Slicer's paid AI, so cards are not accepted in the assistant's plan. Your own photo from the project media is set with the `update_card` operation.
-   **Up to 16 frames per call, up to 400 observations per plan.** Calls count towards the shared [MCP rate limit](https://docs.slicer.media/en/mcp/limits/).
-   **No director rules in the answers.** Neither the brief, nor the prompt, nor the tool results contain the rules of the Slicer AI director — only your material, general tips, fixes and issues.
-   **Only a project ready for edits.** While the video is rendering — `409 busy`; if the sources were deleted after the retention period — `409 sources_expired`.

## The direct\_reel prompt

The MCP prompt `direct_reel` sets the whole workflow in one command: pick it and give the files (`files` — paths or public links to videos, photos and audio) and, optionally, the idea of the video (`idea`). The prompt holds only the workflow: upload, captions from speech with your consent, the brief, frames and observations, the plan and fixing it according to the issues. If your client doesn't support prompts, just ask in words — "Edit this video in Slicer yourself" — and the assistant takes the same path. How to call prompts in different clients — [Prompts](https://docs.slicer.media/en/mcp/prompts/).

## Example conversation

> Edit a video yourself in Slicer from `~/Movies/latte-art.mp4` and `~/Movies/cafe.mp4`: 30 seconds, dynamic pace, hook "Latte art in a minute".

1.  The assistant uploads both files and creates an Edit it myself project.
2.  The first video has speech — it names the recognition price and, after your yes, runs `transcribe_speech`.
3.  `get_director_brief` with `pace: "dynamic"` and `targetDurationSec: 30` — the material by words, the plan and observation schemas.
4.  `get_frames` — 8 frames of each video, then 6 more around the moment the barista draws the heart. The observations cover the talk at the counter, the latte art and the guests with cups.
5.  `submit_director_plan` — the hook, three complete thoughts from the barista, cutaways of the pattern and the cup in a guest's hands. A `cuts_thought` issue on the second fragment: the assistant extends it to the end of the thought and submits the plan again — no issues.
6.  The assistant's answer:

> Done: a 28-second video — the hook "Latte art in a minute", three steps from milk to pattern and a close-up of the finished heart at the end. I adjusted the framing of the second fragment so the cup is centred. The project link is in the app. Export in 1080p?

Only speech recognition was paid; the brief, frames, both plans, edits and export were free.

## What's next

[ToolsEvery MCP server tool with its parameters.](https://docs.slicer.media/en/mcp/tools/)[Promptsdirect\_reel and other scenarios in one command.](https://docs.slicer.media/en/mcp/prompts/)[Data and privacyWhat the assistant receives when it looks at frames.](https://docs.slicer.media/en/mcp/privacy/)[The same in the APIBrief, frames, plan and issues for your code.](https://docs.slicer.media/en/api/editing/#own-director)