> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getjumper.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Agentic editing

> AI agents operating Jumper to orchestrate multi-step media workflows

export const ChatStatus = ({children}) => {
  return <div className="flex items-center gap-3 w-full py-1">
      <div className="flex-1 border-t border-gray-200 dark:border-white/10" />
      <span className="text-xs text-muted-foreground shrink-0 flex items-center gap-1">
        {children}
        <Icon icon="chevron-right" size={10} className="opacity-50" />
      </span>
      <div className="flex-1 border-t border-gray-200 dark:border-white/10" />
    </div>;
};

export const ChatResponse = ({children}) => {
  return <div className="self-start w-full max-w-[85%] min-w-0 flex flex-col gap-1">
      <span className="text-xs pl-2 font-semibold opacity-50">AGENT</span>
      <div className="rounded-xl rounded-bl-sm px-2 py-3 text-sm text-gray-800 dark:text-gray-100">
        <div className="prose prose-sm dark:prose-invert max-w-none overflow-x-auto">
          {children}
        </div>
      </div>
    </div>;
};

export const ChatMessage = ({children}) => {
  return <div className="self-end flex flex-col gap-1 max-w-[75%]">
      <span className="text-xs pl-2 font-semibold opacity-50">USER</span>
      <div className="rounded-xl rounded-br-sm dark:border dark:border-gray-500 px-4 py-2.5 text-sm bg-gray-100 dark:bg-white/20 dark:text-white">
        {children}
      </div>
    </div>;
};

export const Chat = ({children}) => {
  return <div className="not-prose chat-interface p-4 mb-14 border border-gray-200 dark:border-none dark:bg-white/10 rounded-lg">
      <div className="flex flex-col gap-3 my-2">{children}</div>
    </div>;
};

<img src="https://mintcdn.com/jumper/xt0GU_nmI-mbM0Ip/images/agentic_editing_hero.png?fit=max&auto=format&n=xt0GU_nmI-mbM0Ip&q=85&s=4e6026da41a11b38bce1c4c86937ed52" alt="agentic_editing_hero.png" width="2400" height="1260" data-path="images/agentic_editing_hero.png" />

## Overview

Agentic editing lets AI agents operate Jumper directly (searching your footage, retrieving clips, and triggering workflow actions) through an <Tooltip headline="MCP (Model Context Protocol)" tip="An open standard for AI agents to 'talk' with software">MCP</Tooltip> server. Jumper integrates with Claude Code Desktop, Claude Code CLI, OpenAI Codex Desktop, and LM Studio, so you can give a natural-language task to an agent and have it break the work into steps and execute them.

Instead of clicking through searches and exports yourself, you describe what you want in plain language. The agent queries Jumper's backend, orchestrates the workflow, and produces the result (clips, sequences, exports) without you having to perform each step manually.

## What agents can do

### Same as you

Agents can use Jumper much like you do through the interface:

* **Search visually** across analyzed footage using natural language
* **Search transcriptions** for spoken words and phrases
* **Retrieve clip segments** with start and end times
* **Find similar clips** by text, image, or frame
* **Find clips by face recognition** (people search)
* **Trigger workflow actions** such as exporting a sequence to Premiere Pro, Final Cut Pro, DaVinci Resolve, or Avid Media Composer
* **Read timelines** from Premiere Pro, DaVinci Resolve, and Avid Media Composer
* **Send edited timelines back** to the active NLE project

### Beyond the UI

Because the agent orchestrates Jumper programmatically, it can also do things the normal interface does not:

* **Export scenes as individual files** to a folder
* **Export a set of clips as a sequence** for your editing software (Premiere XML, FCPXML, etc.)

The agent combines these capabilities into multi-step workflows that would otherwise require manual repetition.

### Timeline import and export

Agents can read the active timeline from Premiere Pro, DaVinci Resolve, or Avid Media Composer, then send an edited version back to the same NLE. This supports round-trip workflows such as:

* Pulling a rough cut from the NLE, finding better takes or b-roll for each clip, and updating the timeline
* Auditing a sequence against script notes or a shot list
* Rebuilding a timeline from search results while preserving structure from the original edit

The agent receives timeline metadata (clips, timecodes, track layout) through MCP. Jumper still runs all search and analysis locally. Your footage does not leave your machine.

<Chat>
  <ChatMessage>
    Read my current Premiere timeline, find calmer landscape b-roll for each clip, and update the timeline with the best matches.
  </ChatMessage>

  <ChatStatus>
    Worked for 2m 10s
  </ChatStatus>

  <ChatResponse>
    Updated the active Premiere sequence with 14 replacement clips. Review the timeline in Premiere before locking the cut.
  </ChatResponse>
</Chat>

## Orchestration

The agent acts as the orchestrator: you give it a complex task, and it breaks it down into smaller steps and runs them in the right order. The agent decides how to search, filter, and export, then executes the workflow end to end.

## Example use cases

Agentic editing can speed up routine media production tasks:

* Finding B-roll that matches a script
* Pulling every clip of a certain person across a large library
* Creating sequences of selects for review or rough cuts
* VO + B-roll workflows (e.g. sizzle reels from event footage with a voiceover track)

The same pattern applies to many other tasks that involve repeated search, selection, and export steps.

<Chat>
  <ChatMessage>
    Use Jumper to find all shots of Anna smiling, export them as individual files, and also export a sequence to Premiere.
  </ChatMessage>

  <ChatStatus>
    Worked for 50s
  </ChatStatus>

  <ChatResponse>
    Export finished. The Premiere XML timeline is saved at <code>\~/jumper\_test\_movies/anna\_smiling\_sequence.xml</code>

    **Sequence:** Anna smiling

    **Clips:** 20 (\~1:20 total duration)

    The clips are in <code>\~/jumper\_test\_movies/anna\_smiling\_clips/</code>

    In Premiere Pro, use File -> Import and select the XML file. A sequence named "Anna smiling" will be added with all 20 clips in order. Ensure the source media is imported in your project first, or let Premiere relink if paths differ.
  </ChatResponse>
</Chat>

<Chat>
  <ChatMessage>
    Use Jumper to cut a sizzle reel from the event footage in <code>/day1\_footage/</code> with the voiceover <code>sizzle\_reel\_audio.wav</code>.
  </ChatMessage>

  <ChatStatus>
    Worked for 1m 15s
  </ChatStatus>

  <ChatResponse>
    Export finished. The sizzle reel with synced voiceover has been created.

    **Sequence file:** <code>\~/day1\_footage/sizzle\_reel\_with\_vo.xml</code>

    * **Clips:** 12 (cut to match voiceover timing)
    * **Voiceover:** <code>sizzle\_reel\_audio.wav</code> (synced)

    Drag it to your timeline to add it to your project.
  </ChatResponse>
</Chat>

## Parallel workflows

Jumper can server multiple agents sessions at the same time. As each agent can work on different tasks, you can fire off several jobs in parallel and focus on other work while they complete.

## Skills in Agentic Editing

Skills are how you encode repeatable editing workflows for the agent. Each skill is a <code>SKILL.md</code> file that defines when the workflow should be used, what steps it runs, and how results should be returned.

### Why skills matter

* **Predictable behavior** — Same workflow runs consistently across sessions and across editors.
* **Shorter prompts** — Process logic lives in reusable instructions instead of long conversation context.
* **Standardized quality** — Teams can enforce naming conventions, export formats, and review checks.
* **Specialized workflows** — Complex or domain-specific steps stay out of the general conversation loop.

### What you can customize

1. **Modify shipped skills** — Tune existing workflows for your editorial style (clip length bias, pacing, selection thresholds, export defaults).
2. **Add new skills** — Create workflows for jobs your team repeats often (e.g., social cutdowns, b-roll sequences, interview selects).

To learn how to add custom skills, see [Add a custom skill](/guides/add-custom-skill).

## Compatibility

Jumper is currently compatible with:

* **Claude Code Desktop**
* **Claude Code CLI**
* **OpenAI Codex Desktop**
* **LM Studio**

<Warning>
  Claude Cowork currently does not reliably pick up the Jumper integration. For Jumper workflows, use Claude Code Desktop or Claude Code CLI.
</Warning>

To connect Jumper to an AI agent, use the **AI Agent** section in the [Settings tab](/interface/settings-tab#ai-agent). Setup is one-click for Claude and Codex.

For LM Studio, use the [LM Studio setup guide](/guides/lm-studio). That workflow uses LM Studio's own MCP integrations instead of Jumper's one-click install buttons.

## On Privacy

**Will my footage be uploaded to AI companies?** No.

Here's how it works: the agent (Claude, Codex, etc.) talks to Jumper via MCP (an open standard for AI agents to "talk" with software).

It sends *commands* like "search for shots of Anna smiling" or "export clips to this folder." Jumper runs a **local server** on your machine (localhost). All the heavy work (visual search, transcription, face recognition) happens **on your computer**. Your footage never leaves it.

What the agent receives back is **metadata** only: file paths, timecodes, transcript excerpts, search result lists. The agent orchestrates the workflow; Jumper does the actual analysis locally and returns pointers to where things are, not the footage itself.

For a detailed breakdown of what data the agent receives and how model providers handle it, see [Agentic editing and data privacy](/core-concepts/agentic-editing-privacy).

## Related

<CardGroup>
  <Card title="Your first agentic editing export" horizontal arrow="true" href="/tutorials/agentic-editing">
    Step-by-step walkthrough of searching and exporting clips via an AI agent
  </Card>

  <Card title="Settings: AI Agent" horizontal arrow="true" href="/interface/settings-tab#ai-agent">
    Configure and connect Claude or Codex to Jumper
  </Card>
</CardGroup>