The Idea

A post-production studio handles dozens of file handoffs every day. Camera originals from set. Exports from editorial. Handles for color. Stems for sound. Finals for the client. Each handoff involves someone putting files in the right place and telling the right person they're there. That coordination work is repetitive, error-prone, and exactly the kind of thing an AI agent can handle.

The setup: Claude Desktop connected to four things — Handrive for file operations, ffmpeg for media processing, Slack for team notifications, and email for client communication. Claude watches for incoming files, understands what they are based on naming conventions and folder structure, transcodes or validates them when needed, routes them appropriately, and notifies the right people through the right channel.


┌───────────────────────────────────────────────────────────────┐
│                       Claude Agent                             │
│                                                                │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐         │
│  │Handrive │  │ ffmpeg  │  │  Slack  │  │  Email  │         │
│  │  (MCP)  │  │  (CLI)  │  │  (MCP)  │  │  (MCP)  │         │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘         │
└───────┼────────────┼────────────┼────────────┼───────────────┘
        │            │            │            │
   File ops     Transcode    Team alerts  Client comms
        │        Validate         │            │
   ┌────┴────┐  ┌────┴────┐ ┌────┴────┐  ┌────┴────┐
   │Handrive │  │ Proxies │ │ #post-  │  │ Client  │
   │ Server  │  │ QC      │ │ prod    │  │ inbox   │
   │ (24/7)  │  │ Thumbs  │ │ channel │  │         │
   └─────────┘  └─────────┘ └─────────┘  └─────────┘

What You Need

Three MCP servers and one CLI tool connected to Claude Desktop:

Handrive MCP — 40+ tools for file operations: listing shares, monitoring transfers, moving files, managing members. This is the file backbone.
ffmpeg / ffprobe — The agent calls ffmpeg and ffprobe via the command line to transcode, generate proxies, extract thumbnails, and validate media specs. This is the media processing layer.
Slack MCP — Post messages to channels, send DMs, read channel history. This is how the agent talks to your team.
Email MCP — Send emails, read inbox, manage drafts. This is how the agent communicates with clients and external vendors.

On the Handrive side, you need a cluster set up: a headless node on your NAS or studio server running 24/7 as the always-on endpoint, with workstations connected as additional nodes. See the studio file cluster guide for the full setup.

Configuring Claude Desktop

In Claude Desktop's settings, add Handrive as an MCP server. The configuration points Claude at your running Handrive instance:

// claude_desktop_config.json
{
  "mcpServers": {
    "handrive": {
      "command": "hand",
      "args": ["mcp"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/slack-mcp"]
    }
  }
}

Once connected, Claude has access to every Handrive operation: listing shares, reading file manifests, checking transfer status, adding members, and more. Combined with Slack, it can monitor and communicate in real time.

Workflow 1: Dailies Intake

The most common file handoff in any production. Camera cards come off set, DIT copies them, and the footage needs to reach the editors. Traditionally this means someone copies files to the NAS, sends a Slack message, and hopes the editor checks the right folder.

With the AI agent, the prompt looks like this:

"Monitor the 'Dailies Incoming' share on Handrive.
When new files appear:
1. Check the file names for camera roll and date info
2. Run ffprobe on each clip to get codec, resolution,
   frame rate, and duration
3. Generate H.264 proxy copies for editorial:
   ffmpeg -i input.mxf -c:v libx264 -preset fast
   -crf 23 -vf scale=1920:-2 proxy_output.mp4
4. Extract a thumbnail from each clip at the 2s mark:
   ffmpeg -i input.mxf -ss 2 -frames:v 1 thumb.jpg
5. Post to #dailies in Slack with: clip count, total
   size, camera rolls, codec info, and thumbnails
6. Tag @editor-team with the summary
7. Share proxies to 'Dailies Proxies' via Handrive
8. If total size exceeds 500GB, also DM the post
   supervisor"

The DIT drops files into the share from set. The agent detects them, runs ffprobe to read the technical metadata, generates lightweight H.264 proxies and thumbnails, posts a rich summary to Slack with clip details and visual previews, and shares the proxies via Handrive so editors can start cutting immediately — even before the full-res originals finish transferring to every workstation.

Workflow 2: Editorial to Color Handoff

When the editor locks a cut, they export an EDL/XML, the timeline media, and any handles the colorist needs. Normally this is a Slack message saying “color files are on the server” with a folder path. Sometimes the message gets lost. Sometimes the path is wrong.

"When files appear in 'Editorial Exports':
1. Look for EDL or XML files to confirm this is a
   color handoff (not just random exports)
2. List all files and total size via Handrive
3. DM the colorist on Slack with the file list
4. Post in #color-pipeline with the share link
5. If no EDL/XML found, ask in #editorial whether
   the conform files are coming separately"

The agent understands context. It doesn't just forward files blindly — it checks that the handoff package is complete before notifying the colorist. If the EDL is missing, it flags it in Slack before the colorist wastes time pulling incomplete media.

Workflow 3: Remote Sound Delivery

Your sound designer works from home. When the mix is done, they drop stems into a Handrive share. The agent picks it up:

"Monitor 'Sound Deliveries' share.
When new stems arrive:
1. Run ffprobe on each file to verify:
   - Format: WAV expected (flag if MP3 or AAC)
   - Sample rate: 48kHz (flag if 44.1kHz)
   - Bit depth: 24-bit (flag if 16-bit)
   - Duration: all stems should match within 1 frame
2. Check that stem count matches the template
   (dialog, music, effects, mix - 4 minimum)
3. If any file fails spec: DM the sound designer
   with exact details ('Effects stem is 44.1kHz,
   expected 48kHz')
4. If stems are incomplete, DM the sound designer
   asking which stems are still coming
5. If all stems present and specs pass:
   - Post to #sound-pipeline with file list and specs
   - DM the editor: 'Mix stems ready for layback -
     all 4 stems verified 48kHz/24-bit WAV'"

The agent is a QC layer with teeth. It doesn't just count files — it verifies sample rate, bit depth, and duration using ffprobe. A 44.1kHz stem in a 48kHz project causes pitch shift on layback, and that's the kind of mistake that wastes an hour of debugging. The agent catches it in seconds and tells the sound designer exactly what's wrong.

Workflow 4: Client Delivery

Finals ready, client needs them. This is where email comes in:

"When files appear in 'Client Deliverables':
1. List all files with names and sizes
2. Verify naming convention matches the client's spec
   (ProjectName_Version_Date format)
3. Run ffprobe to validate each file against the
   delivery spec:
   - Codec: ProRes 422 HQ expected
   - Resolution: 1920x1080
   - Frame rate: 23.976
   - Audio: 48kHz, 24-bit, stereo or 5.1
4. If any file fails validation, post the mismatch
   to #deliveries and DM the editor — do NOT send
   to client
5. If all files pass: add the client's email to the
   Handrive share for direct P2P access
6. Generate a poster frame thumbnail from each file:
   ffmpeg -i input.mov -ss 5 -frames:v 1 poster.jpg
7. Send the client an email:
   - Subject: 'Project [name] - Deliverables Ready'
   - Body: file list with specs, poster frame,
     access instructions
8. Post confirmation to #deliveries in Slack
9. DM the producer with delivery confirmation"

The ffprobe validation step is critical. Without it, a wrong-spec file goes straight to the client and you get an email three hours later saying the codec is wrong. With it, the agent catches the mismatch before anyone outside the studio sees it. The client gets a professional email with a poster frame preview, accurate file specs, and direct P2P access — no cloud links that expire in 7 days, no file size caps, no per-GB charges.

Workflow 5: Daily Status Report

At the end of each day, the agent can compile a summary:

"At 6pm each day, generate a status report:
1. List all transfers completed today via Handrive
2. Summarize: total files moved, total data transferred
3. Note any failed or stalled transfers
4. Post the summary to #daily-status in Slack
5. Email the post supervisor with the same summary"

The post supervisor gets a clear picture of everything that moved through the studio that day without checking multiple systems or asking five different people.

Why This Works Better Than Scripts

You could automate some of this with shell scripts, cron jobs, and webhook integrations. Studios have been doing that for years. But scripts are brittle. They break when file naming conventions change, when someone puts files in the wrong folder, when a new project doesn't match the expected pattern.

An AI agent handles ambiguity. If the stems are named differently than expected, it can still figure out which is the dialog stem and which is the effects stem. If someone puts color files in the wrong share, it can recognize what they are and ask whether to move them. If a client emails back with questions about the delivery, the agent can read the email and respond with accurate file details pulled from Handrive.

The other advantage: you don't need a developer to maintain it. The workflow definitions are plain English prompts. When a process changes, you update the prompt in Claude Desktop, not a Python script buried in a cron job on a server nobody remembers the password to.

Security

Files never leave your infrastructure. Handrive transfers are encrypted and peer-to-peer — there's no cloud intermediary holding your media. The MCP connection between Claude and Handrive runs locally on your machine. Slack and email MCP servers authenticate through their respective OAuth flows, and Claude doesn't store credentials.

The agent sees file names, sizes, and share structure through Handrive MCP, but actual file content doesn't pass through the AI — it orchestrates the transfer, it doesn't read your ProRes files.

Getting Started

Start with one workflow. Dailies intake is the easiest because it's the most predictable: files come in, agent lists them, agent posts to Slack. Once that's running smoothly, add the editorial-to-color handoff, then client delivery. Each new workflow is just a new prompt — the infrastructure is already in place.

You'll need:

Handrive installed and running (cluster setup guide)
Claude Desktop with Handrive MCP configured
ffmpeg and ffprobe installed on the agent's machine (most studio machines already have these — if not, brew install ffmpeg on macOS or sudo apt install ffmpeg on Linux)
Slack MCP server connected to your workspace
Email MCP server for client communication

The whole setup takes about 30 minutes if you already have the Handrive cluster running. Most of that is configuring the Slack and email MCP connections. After that, it's just writing prompts.

Automate Your Studio File Workflow

Connect Claude to Handrive, Slack, and email. Let an AI agent handle your file routing and notifications.

Download Handrive MCP Integration Guide