AI Agent Workflow Automation for Photographers: Save Hours with Claude and Mochify

Cheat Sheet: Agent Workflow at a Glance

Configure each row once. After that, dropping a folder triggers the full pipeline automatically — no manual steps in between.

Why Photographers Still Lose Time After the Shoot Ends

The export is not the finish line. After Lightroom or Capture One finishes, you still need to generate platform-specific derivative sets, strip location data, confirm file sizes are within each platform's limits, and move files to the right delivery folders.

You're not sitting idle — you're travelling between locations, meeting clients, or trying to sleep — but the work is still waiting.

When an agent handles this, the window collapses to under 60 seconds for a 25-image batch at Pro tier. You configure the agent's instruction set once, and it fires automatically every time a new export lands. You get a notification when the files are ready. Nothing else required.

How the Stack Works: Claude, Dispatch, and Mochify MCP

The three-layer architecture is straightforward: an AI agent runtime handles orchestration, a scheduler handles triggers, and Mochify's MCP server is the image processing engine the agent calls. The agent handles the logic; Mochify handles the actual pixel work.

Claude (via Claude Desktop or a compatible client) is where you define instruction sets — essentially, pre-written tasks the agent executes when triggered. For this workflow, you write the instruction set once: detect the shoot type from the folder name, call Mochify MCP with the appropriate conversion parameters, and send a confirmation when done. Anthropic's MCP documentation covers the protocol spec in detail for developers who want to go deeper.

Dispatch is the scheduling and trigger layer. It runs a file watcher on your /exports/raw-jpegs/ directory and fires the agent job when a new folder appears. This is what makes the workflow genuinely hands-off: the export from Lightroom is the only action you take. Dispatch handles everything after.

Mochify's MCP server exposes the same C++ compression engine and zero-retention pipeline as the web interface — but callable by an AI agent in natural language. The agent describes the task: format, size constraints, colour profile, EXIF handling. Mochify resolves the parameters and returns the processed files. No settings UI, no format dropdowns.

Setting Up the Folder Structure and Agent Trigger

Get the folder structure right first, because the agent infers shoot type from path conventions — getting this wrong means the agent will not know which derivative set to generate.

Here's the recommended local structure:

/studio/
  exports/
    raw-jpegs/          ← Lightroom drops files here via post-export action
  processed/
    pixieset/
    shopify/
    etsy/
    wire/
  archive/

The naming convention for the raw-jpegs/ subfolders is critical. Use a consistent prefix that maps to a shoot type:

• wedding-YYYY-MM-DD-clientname/ — triggers the wedding instruction set (Pixieset delivery)
• commercial-YYYY-MM-DD-clientname/ — triggers the commercial instruction set (Shopify + Etsy)
• editorial-YYYY-MM-DD-outlet/ — triggers the editorial instruction set (wire delivery)

Lightroom's post-export action setting (under the Export dialog's "Post-Processing" panel) lets you specify a shell script to run when an export completes. Point this at a lightweight script that calls Dispatch with the folder path as an argument:

#!/bin/bash
# post-export-trigger.sh
FOLDER_PATH="$1"
dispatch trigger mochify-agent --param folder="$FOLDER_PATH"

Set this script as the "After Export" action in Lightroom. Every export will now fire Dispatch automatically, which fires the agent, which calls Mochify. You set this up once.

The Worked Example: Wedding Shoot, Agent Running, Photographer in the Field

Here's a complete, concrete run-through. It's a Saturday in May 2026. You've just finished the ceremony set. You're in the car park, tablet in hand, and you trigger a Lightroom export over your studio's remote connection.

The equivalent CLI command — for readers who want to test the same conversion manually or script it outside an agent context:

mochify --prompt "Pixieset gallery set, sRGB JPEG, 3600px long edge, under 2MB, strip all EXIF" \
  ./exports/raw-jpegs/wedding-2026-05-03-hartley/*.jpg \
  --out ./processed/pixieset/wedding-2026-05-03-hartley/

The --prompt flag accepts the same natural language instruction as the MCP call. This is useful for one-off runs, debugging, or verifying output before you trust the agent to run unsupervised.

Multi-Destination Derivatives: One Shoot, Four Outputs

For a commercial shoot, you're not delivering to one platform — you're delivering to several with different specs. The agent handles all of them in a single pass, running the instruction sets sequentially.

Here's the prompt sequence the agent runs for a commercial product shoot:

Pixieset gallery (client proofs)

"Convert everything in /studio/exports/raw-jpegs/commercial-2026-05-03-brand/
to sRGB JPEG, 3,600px long edge, under 2MB, strip all EXIF"

Output: /studio/processed/pixieset/commercial-2026-05-03-brand/

Shopify product images

"Generate Shopify derivatives from shoot folder - sRGB JPEG, 2,048px square,
under 500KB, strip EXIF"

Output: /studio/processed/shopify/commercial-2026-05-03-brand/

Etsy listings

"Batch process and strip EXIF - sRGB JPEG, 2,000px long edge, under 1MB,
strip all metadata"

Output: /studio/processed/etsy/commercial-2026-05-03-brand/

Brand website (modern format)

"Convert everything in this folder to sRGB AVIF, under 300KB, strip EXIF"

Output: /studio/processed/web/commercial-2026-05-03-brand/

For a 25-image commercial batch at Pro tier, all four derivative sets complete in under four minutes total. The agent coordinates the sequence, but each Mochify call is independent — if one fails, the others continue.

Privacy in an Automated Pipeline

Privacy matters more in an agent workflow, not less — because files are being processed without you watching. Mochify's in-memory, zero-retention pipeline means no source files are written to third-party disk at any point in the process. The agent passes the task to Mochify, Mochify processes in memory, and the output is returned directly to your local folder. Your originals never leave your machine and no intermediary cloud storage is involved.

EXIF stripping is specified as intent in the Magic Flow prompt — not configured as a separate tool step. You write "strip all EXIF including embedded thumbnails" in the same sentence as your format and size requirements, and Mochify resolves and applies all of it in a single pass. This matters for client privacy: wedding and portrait files contain GPS coordinates, device metadata, and sometimes embedded contact information from your camera profile.

For editorial work, the rule is different. Wire services require IPTC caption and copyright fields to travel with the file for attribution. In that case, use a selective instruction:

"Batch process and strip EXIF - preserve IPTC caption and copyright fields,
strip GPS and device metadata, 2,400px long edge, JPEG"

Magic Flow understands the distinction and applies EXIF stripping selectively. No manual metadata editing needed.

What to Validate and What Can Go Wrong

An automated pipeline is only trustworthy if it validates its own output. Here's what to configure the agent to check before marking a batch complete.

File size validation. The agent should confirm that every output file is within the target platform's size limit before sending the confirmation notification. If any file exceeds the limit, it should re-run that file with a slightly lower quality setting and re-check. Mochify's Magic Flow handles this gracefully — the prompt can specify "under 2MB" as a hard constraint, and the encoder will find the quality level that satisfies it.

Mixed file types. If a folder contains HIF, JPEG, and occasional RAW files (from a second shooter, for example), Mochify processes the formats it supports and skips unsupported types. The agent's instruction set should flag skipped files in the confirmation message rather than silently omitting them.

Batches larger than 25 files. The 25-file batch limit applies to Seller and Pro tiers via MCP. If you're processing 80 files, the CLI handles this automatically by splitting internally across multiple batches — you pass the full folder and Mochify manages the chunking. Via MCP, the agent should split the folder glob into chunks of 25 and call Mochify sequentially, collecting confirmations before marking the job done.

Format rejection. If Lightroom exports a file with an unusual colour profile or embedded ICC profile that causes a processing error, Mochify will return an error for that file. Configure the agent to log errors with filenames and re-queue them for manual review rather than failing silently.

FAQ

Related Guides

• HIF/HEIF to JPEG for Professional Photographers — Privacy-first workflow blueprints for converting camera HEIF files to JPEG for professional delivery.
• How to Use Mochify via MCP: AI Agent Image Compression — Connect Mochify to your AI assistant via MCP and compress images with plain English — no manual settings.
• The Risks of EXIF Data in Image Compression — A complete breakdown of metadata types, privacy risks, and how to strip selectively.
• Privacy & Image Optimization: A Comprehensive Guide — How to keep your images secure with zero-retention optimization in 2026.