---
title: Let a person tweak the cut your agent made in Premiere Pro or DaVinci Resolve
description: Your agent builds the cut, an editor adjusts it in Premiere Pro or DaVinci Resolve, and the agent brings the tweak back onto a branch in invideo.
---
You end up with an agent's cut that a person has adjusted by hand in their own editor, back in invideo as a timeline your team keeps working on. This is a round trip, also called an NLE hand-off: your agent exports a project file, the editor tweaks it in Premiere Pro or DaVinci Resolve, and your agent imports the result onto a branch.

Use invideo for this when the agent does the heavy lifting, a person wants the last word in the editor they know, and the edit has to stay editable afterward, with captions, music and versions still to come.

## Quickest path

Set up your agent first with [invideo for AI agents](/agents). Then give it this prompt:

```text
Build a rough cut from the clips in this project on a branch, check it,
and export it as a Premiere Pro project with its media in a zip. When I
send back the edited XML and media zip, import them onto a new branch,
check the import, and show me frames at the cuts I changed.
```

In a chat app, you drag the edited .xml or .otio and the media zip into the chat. In a terminal, you name the folder that holds them, and the agent runs `invideo edit import`.

## What you need

The editor needs the app and the project's media. Gather these:

- **The footage.** Already in the invideo project, or files for the agent to upload.
- **The editor's app.** Premiere Pro or DaVinci Resolve. Final Cut Pro works with one conversion, see [Use Final Cut Pro with invideo](/integrations/final-cut).
- **What the person may change.** Trims, the order of shots, a grade, the audio mix. Say what stays as it is.
- **The file that comes back.** A Premiere Pro XML (**Final Cut Pro XML** in its export menu) or a Resolve .otio, plus a zip of its media, made with `zip -0 -r`.

## Steps

The round trip has two halves: out to the editor, and back into invideo.

### Out to the editor

<Steps>
<Step title="Build the cut on a branch">
The agent creates a branch with `timeline_history` and `action: "create_branch"`, then places and trims the clips with `edit_timeline`. Expected result: a `branch_url` and a new `state_token` after each change.
</Step>
<Step title="Check and save a checkpoint">
The agent runs `check_timeline` and `capture` at the cuts, then saves a checkpoint with `timeline_history` and `action: "checkpoint"`. Expected result: no findings, and a checkpoint the import can be compared with.
</Step>
<Step title="Export the project file">
The agent calls `export` with `format` `premiere` or `davinci`, `options` `media_packaging` `zip`, and an `idempotency_key`. It reads the card until the media zip is listed. Expected result: an export card with status `completed`, a project file and a zip.
</Step>
<Step title="Hand it to the editor">
You open the project in Premiere Pro or DaVinci Resolve and make the changes. Then you export a Premiere Pro XML or a Resolve .otio, and zip its media. Expected result: one project file and one media zip.
</Step>
</Steps>

### Back into invideo

<Steps>
<Step title="Make a branch for the tweak">
The agent creates a new branch with `timeline_history` and `action: "create_branch"`, named for the editor. Expected result: a second `branch_url`. The agent's own branch stays as it was.
</Step>
<Step title="Check the file names">
The agent calls `import_timeline` on that branch with `dry_run: true`, `project_file_name` and `media_file_name`. Expected result: `status` `checked`.
</Step>
<Step title="Upload and import">
The agent calls `start_upload` for each file and PUTs the bytes to its `upload_url`. Then it calls `import_timeline` with `project_upload_id`, `media_upload_id` and an `idempotency_key`. Expected result: one timeline per sequence, and a checkpoint of the branch's old state.
</Step>
<Step title="Check the import">
The agent reads the branch URL until the media has landed. Then it runs `check_timeline`, and `capture` at the cuts the person changed. Expected result: frames that match the editor's version.
</Step>
<Step title="Continue in invideo">
With your yes, the agent makes the editor's branch the default with `timeline_history` and `action: "set_default"`. It adds captions, music or more versions there. Expected result: the team works on the tweaked cut.
</Step>
</Steps>

The key MCP call is `import_timeline`. This is the full call after the uploads:

```json
{
  "url": "<branch-url>",
  "as": "<name>",
  "project_upload_id": "<project-upload-id>",
  "media_upload_id": "<media-upload-id>",
  "idempotency_key": "editor-tweak-v1"
}
```

`<branch-url>` is the editor's branch, from `timeline_history`. `<name>` is the name you chose with `register`. `<project-upload-id>` and `<media-upload-id>` are the `upload_id` values `start_upload` returns.

The whole round trip from a terminal:

```bash
invideo agent register <project-url> --name <name>
export INVIDEO_AS=<name>
invideo edit show <edit-url>
invideo branch new <edit-url> --name agent-cut --token <state_token>
invideo edit check <branch-url>
invideo edit capture <branch-url> --at 0,5,10 --out ./frames
invideo branch checkpoint <branch-url> --title "to the editor" \
  --token <state_token>
invideo edit export <branch-url> --format premiere \
  --media-packaging zip --idempotency-key "to-editor-v1" --json
invideo status <card-url> --wait
invideo notebook show <card-url> --out ./to-editor
invideo branch new <edit-url> --name editor-tweak --token <state_token>
invideo edit import <tweak-branch-url> cut.xml media.zip \
  --idempotency-key "editor-tweak-v1"
invideo edit check <tweak-branch-url>
```

Where each value comes from:

- `<project-url>` comes from `list_projects` or `invideo project new`. `<name>` is the name you chose in `invideo agent register`.
- `<edit-url>` is the timeline's URL. `<state_token>` comes from `invideo edit show` on the URL you change, read again after every change.
- `<branch-url>` and `<tweak-branch-url>` are the `branch_url` values that `invideo branch new` returns.
- `<card-url>` is `.sequences[0]` of the export answer. Run `notebook show` again until the media zip is in its files.
- cut.xml and media.zip are the files the editor sends back. `invideo edit import` uploads both and takes no `--dry-run`.

For DaVinci Resolve, export with `--format davinci` and import the .otio the editor sends back.

### Review in invideo instead

A person who only wants to give notes does not need an editing app. Click **Share** in the project, add them by email, and set the role to **Preview only**. They see the preview tab and the timeline previews, and they comment by timecode. You pass the notes to your agent, and it makes the changes on a branch. Agent Two, the in-app agent, reads review comments itself. See [Share a timeline for review](/projects-and-exports/how-to-share-a-timeline-for-review-in-invideo-editor).

## Cost and time

Edits and exports are free. Generation and transcripts cost credits. Paid stock costs a small credit charge, or one of your workspace's iStock licenses. Your agent runs a dry run first and tells you the price before it spends anything.

The round trip itself uses edits, an export, uploads and an import, and nothing on this page generates media. Captions or music added after the import follow their own pages. The export and the import each take a few minutes. The editor's part takes as long as the changes do. See [Credits](/account/credits).

## If something goes wrong

Most problems come from the file type, the media zip, or the branch.

| Symptom | Fix |
| --- | --- |
| `code` `import_format`: "it takes .xml, .otio" | A .prproj, .drp or .fcpxml does not import. Export a Premiere Pro XML or a Resolve .otio. |
| `code` `several_timelines` | The URL reaches more than one timeline. Call again with one of the timeline URLs the message lists, on the editor's branch. |
| "media_upload_id takes a .zip of the project's media" | Zip the media folder with `zip -0 -r`, then upload the .zip. |
| "Pass the project's media" | Pass `media_upload_id` or `media_drive_link` with the project. |
| A clip has no media after the import | That file was not in the zip. Its clips keep their timing. Add the file and import again with a new `idempotency_key`. |
| The import looks different from the editor's version | Some effects, titles and grades change between apps. Compare `capture` frames with the editor's screen, and fix the difference on the branch. |
| Avoid: import onto the agent's branch or main | Instead: import onto a new branch. The import replaces the branch it lands on. To undo, restore the checkpoint with `timeline_history` and `action: "restore"`. |
| Avoid: resend after a timeout | Instead: retry with the same `idempotency_key`. It finds the first import or export. |
| Avoid: say done without looking | Instead: run `check_timeline` and `capture` on the imported branch first. |
| Exit code 6, or `status` is `held` | A safety review, not a refusal. Wait, then run `invideo status <url> --wait` again. Do not resend. If it ends `failed`, change the input the review flagged. |

## Prompts to try

A Resolve colorist pass:

```text
Export this branch as a DaVinci Resolve project with its media. When the
colorist sends back the .otio and the media zip, import them onto a branch
called color-pass and show me before and after frames at each shot.
```

A notes-only review:

```text
Share this project with my client as preview only. When I paste their
notes, make the changes on a new branch and list each change you made.
```

A second round:

```text
The editor changed the ending again. Import this new XML and media zip
onto a fresh branch, compare it with the last import, and tell me which
cuts moved.
```

## When to use something else

invideo moves the timeline between apps, not every app's own features. A Premiere Pro project with After Effects compositions, or a Resolve timeline with Fusion effects, keeps those effects in the app it was made in. Render those parts as clips there. A person who edits in Final Cut Pro converts the .fcpxml first, with DaVinci Resolve or a converter.

## Related

- [Use Premiere Pro with invideo](/integrations/premiere)
- [Use DaVinci Resolve with invideo](/integrations/davinci-resolve)
- [Export to Premiere Pro, DaVinci Resolve or Final Cut Pro](/how-to/export-to-premiere-resolve-final-cut)
- [Check your video before you say it is done](/how-to/check-your-video)
- [Deliver in 4K or HDR from an invideo cut](/how-to/film/4k-and-hdr-delivery)