The Gap Between Export and Next Step

Every editing tool has a render or export function. You set your output path, pick a codec, and hit go. When it's done, you have a file sitting in a folder. Then what?

For most editors, “then what” is manual. You copy the file to the server. You open Slack and tell someone it's ready. You rename it to match the client's naming convention. You drag it into a Handrive share so the colorist can pull it. Every export triggers the same manual choreography, and if you forget a step — the colorist doesn't know the grade is ready, the client doesn't get the review cut, the sound designer is waiting on stems that are sitting in the wrong folder.

An AI agent fills that gap. It watches your NLE's output directories, understands what just happened based on file type and naming patterns, and handles everything that comes after the render. The editor's job ends at “Export.” The agent takes it from there.

How It Works

The agent uses Handrive MCP to monitor shares and move files, ffmpeg/ffprobe for media inspection and transcoding, Slack MCP to notify your team, and email MCP for client communication. It runs alongside your NLE on the same workstation (or on a studio server watching the same network storage).

The key insight: each NLE has predictable export behaviors. Resolve always writes to a specific deliver page output folder. Premiere writes to wherever AME is configured. Avid exports to a known location. The agent watches those locations and reacts.


┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Resolve    │     │   Premiere   │     │     Avid     │
│   Deliver    │     │     AME      │     │    Export    │
└──────┬───────┘     └──────┬───────┘     └──────┬───────┘
       │                    │                    │
       ▼                    ▼                    ▼
┌─────────────────────────────────────────────────────────┐
│              NLE Output Directories                      │
│  /renders/resolve/  /renders/premiere/  /renders/avid/  │
└────────────────────────┬────────────────────────────────┘
                         │
                         ▼
              ┌─────────────────────┐
              │    Claude Agent     │
              │                     │
              │  Detects new file   │
              │  ffprobe → inspect  │
              │  ffmpeg → transcode │
              │  Handrive → route   │
              │  Slack/Email →      │
              │    notify           │
              └─────────────────────┘

DaVinci Resolve

Resolve's Deliver page exports to a configured output path. Most studios standardize this per project. The agent watches that path and interprets what it finds:

"Monitor the Resolve render output directory.
When new files appear:

1. Run ffprobe to get codec, resolution, frame rate,
   color space, and duration

2. Classify based on ffprobe output:
   - ProRes 4444 / EXR → grading output
   - H.264 / H.265 → review cut
   - DPX sequence → VFX plate

3. For grading output:
   - Share via Handrive to 'Color Deliveries'
   - Generate an H.264 review proxy with ffmpeg:
     ffmpeg -i grade.mov -c:v libx264 -crf 20
     -vf scale=1920:-2 grade_review.mp4
   - Extract a poster frame at the 10s mark
   - Post to #color-pipeline with poster frame,
     resolution, color space, and duration
   - Share the proxy to 'Review Proxies'

4. For review cuts:
   - Run ffprobe to verify spec matches client
     requirements (resolution, codec, audio layout)
   - Share to 'Client Review', send email with
     poster frame and file details

5. For VFX plates:
   - Count frames in DPX sequence
   - Share to 'VFX Incoming', DM the VFX supe with
     frame range and resolution

6. Log the export to the daily transfer report"

The agent uses ffprobe to read the actual codec from the file rather than guessing from the extension. A .mov file could be ProRes 4444, ProRes 422 LT, or DNxHR — the extension doesn't tell you. ffprobe does. And when a grading output lands, the agent generates an H.264 review proxy automatically so the editor can watch the grade without pulling the 50GB master to their workstation.

Resolve's Power Bins and Timelines

Studios using Resolve's collaborative workflow often have multiple editors and colorists working in the same project database. Renders come from different timelines on different machines. The agent can differentiate based on timeline name patterns: if it contains “_GRADE_” it goes to the editor for review, if it contains “_REVIEW_” it goes to the client, if it contains “_CONFORM_” it goes back to editorial for approval.

Premiere Pro

Premiere exports through Adobe Media Encoder (AME), which has its own output queue and watch folder capabilities. But AME only handles the render — it doesn't know what to do with the file afterward.

"Monitor AME output directories.
When a new render completes:

1. Parse the filename for sequence name and version
   (AME preserves the Premiere sequence name)

2. Check the preset used:
   - 'Client Review' preset → route to client share
   - 'Master Export' preset → route to archive
   - 'Color Handoff' preset → route to colorist

3. For client review cuts:
   - Create a timestamped Handrive share:
     'Review_ProjectName_v3_2026-03-20'
   - Add the client's email
   - Send delivery email with file name, duration,
     and codec info
   - Post to #client-deliveries in Slack

4. For color handoffs:
   - Check that an EDL or XML was also exported
     (look in the same output directory)
   - If conform files present: bundle everything into
     the 'Color Incoming' share, notify colorist
   - If missing: post in #editorial asking for XML"

The Premiere workflow is where the agent's ability to check for completeness really matters. An editor might export the ProRes master but forget to export the XML for the conform. The agent catches that before the colorist tries to start and realizes half the package is missing.

Handling AME's Batch Queue

Editors often queue multiple exports in AME — a review cut, a social media version, and an archival master from the same timeline. The agent can group these by source sequence name and wait until the batch completes before notifying. It runs ffprobe on each file to build an accurate summary instead of guessing from filenames: “Episode 7 exports complete: review cut (H.264, 1920x1080, 23.976fps, 1.2GB), social cut (H.264, 1080x1920, 340MB), master (ProRes 4444, 3840x2160, 48GB).”

If the social media cut needs a different aspect ratio or format that the editor forgot to set in AME, the agent can handle it with ffmpeg. An editor exports a 16:9 master, and the agent auto-generates a 9:16 vertical crop for social delivery:

ffmpeg -i master_16x9.mov \
  -vf "crop=ih*9/16:ih,scale=1080:1920" \
  -c:v libx264 -crf 20 social_9x16.mp4

Avid Media Composer

Avid's export workflow is different from Resolve and Premiere. Media Composer manages its own media files in the Avid MediaFiles directory structure, and exports go through the Output tool or through an AAF/OMF export for audio handoffs.

"Monitor Avid export paths.
When new exports appear:

1. Identify the export type:
   - MXF/MOV → video output, check for sequence name
   - AAF → audio handoff for Pro Tools
   - ALE → metadata log for VFX pull

2. For AAF exports (audio handoff):
   - Share via Handrive to 'Sound Incoming'
   - Include any associated MXF audio media
   - DM the sound designer on Slack:
     'AAF for Episode 7 ready in Sound Incoming'
   - Post to #sound-pipeline

3. For ALE exports (VFX pull):
   - Share to 'VFX Pulls' with associated source clips
   - Post to #vfx-pipeline with shot count from ALE
   - Email the VFX vendor with pull list summary

4. For video exports:
   - Route based on naming convention
   - Log to daily report"

Avid workflows often involve AAF exports for Pro Tools, and this is one of the most error-prone handoffs in post-production. The AAF needs to include the right media references, the audio media needs to travel with it, and the sound editor needs to know exactly which sequence version it came from. The agent verifies that the AAF and its associated media are both present, runs ffprobe on the audio files to confirm sample rate (48kHz) and bit depth (24-bit), and only notifies the sound team when everything checks out. A 44.1kHz audio file in a 48kHz Pro Tools session causes pitch drift — the agent catches that before it wastes anyone's time.

Cross-NLE Scenarios

Most studios don't use just one NLE. Editorial might be on Premiere or Avid, color is in Resolve, and motion graphics are in After Effects. The agent orchestrates across all of them because it's watching output directories, not integrating with a specific application's API.

The Round-Trip

A common workflow: editor cuts in Premiere, exports XML + media for the colorist in Resolve, colorist grades and renders back, editor re-imports the graded media. Each step produces files that the agent can detect and route:


Editor (Premiere)                    Colorist (Resolve)
      │                                     │
      ├── Export XML + ProRes ──────────────▶│
      │   Agent: ffprobe validates specs     │
      │   Agent: routes to Color Incoming    │
      │   Agent: Slacks colorist             │
      │                                      │
      │                              Grade + Render
      │                                      │
      │◀─────────── ProRes 4444 ─────────────┤
      │   Agent: ffprobe reads color space    │
      │   Agent: ffmpeg → H.264 review proxy │
      │   Agent: routes master + proxy        │
      │   Agent: Slacks editor with poster   │
      │                                      │
  Re-import graded media                     │
      │                                      │
      ├── Export master ────────────────────▶ Client
      │   Agent: ffprobe validates delivery   │
      │   Agent: ffmpeg → social media crop   │
      │   Agent: creates share, emails client │

Each arrow in that diagram is a handoff that traditionally requires someone to copy files and send a message. With the agent, each arrow is automatic. The editor exports, walks away. The colorist gets notified. The colorist renders, walks away. The editor gets notified. Nobody copies files manually. Nobody forgets to send the Slack message.

Folder Structure That Makes This Work

The agent is only as smart as the signals you give it. A clean folder structure makes pattern matching reliable:

/studio-server/
├── renders/
│   ├── resolve/         ← Resolve Deliver output
│   ├── premiere/        ← AME output
│   └── avid/            ← Avid Output tool
├── handoffs/
│   ├── color-incoming/  ← XML + media for color
│   ├── color-return/    ← Graded renders back
│   ├── sound-incoming/  ← AAFs for Pro Tools
│   ├── sound-return/    ← Mixed stems back
│   └── vfx-pulls/       ← ALE + source for VFX
└── delivery/
    ├── client-review/   ← Review cuts
    └── final/           ← Finished deliverables

Each of these directories maps to a Handrive share. The agent watches the render directories for new output, then moves files to the appropriate handoff or delivery share. The structure itself encodes the workflow — the agent just follows the logic.

What the Agent Can and Can't Do

The agent doesn't control your NLE. It can't open a Resolve project, start a render, or change timeline settings. It operates on the output — the files that your NLE produces. Think of it as the post-render pipeline, not an NLE plugin.

It can transcode. With ffmpeg, the agent generates review proxies, creates social media crops, extracts poster frames, and converts between formats. It can also validate specs with ffprobe — checking codec, resolution, frame rate, sample rate, and channel layout before routing files anywhere. This makes it a QC layer as much as a routing layer.

What it won't replace: a dedicated transcoding farm for batch encoding hundreds of files, or a color-managed pipeline for delivery masters that need specific ICC profiles. ffmpeg handles the utility transcodes — proxies, review copies, format conversions. Your NLE or dedicated tools handle the quality-critical renders.

Connecting the Pieces

This post focuses on the NLE-to-agent connection. For the full picture:

Studio file cluster setup — connect all your machines into one Handrive network
AI agent studio workflow — the broader orchestration layer: dailies, handoffs, client delivery, status reports
MCP integration guide — configuring Claude Desktop with Handrive
Clustering docs — multi-device and multi-instance setup

Start with the cluster, add the agent, point it at your NLE output folders. The first export that routes itself and notifies the right person without you touching Slack will convince you it's worth the 30 minutes of setup.

Automate Your NLE Pipeline

Connect your editing tools to an AI agent that handles everything after the render.

Download Handrive MCP Integration Guide