# Run cuttingfloor yourself: free and open source

> cuttingfloor is open source (AGPL-3.0). Run the same Docker image that powers cuttingfloor.ai on your own computer for free, change it to fit how you work, or let us run it for you.

Download it, make it your own, or go hosted.

cuttingfloor is free and open source. One Docker image holds the whole editor: the editing engines, the models and the server your agent connects to. It’s the same image that runs cuttingfloor.ai.

- Source: https://github.com/mvp2o-ai/cuttingfloor
- Image: ghcr.io/mvp2o-ai/cuttingfloor
- Licence: AGPL-3.0 (https://github.com/mvp2o-ai/cuttingfloor/blob/HEAD/LICENSE)
- Hosted instead: https://cuttingfloor.ai/connect
- Web page: https://cuttingfloor.ai/self-host

## Quick start

```sh
git clone https://github.com/mvp2o-ai/cuttingfloor && cd cuttingfloor
docker compose up -d
```

Then point your agent at http://127.0.0.1:8787/mcp.

## Connect your agent

- Apps on your computer connect the same way as to hosted: follow your app’s steps on the Connect page, with http://127.0.0.1:8787/mcp in place of the hosted address.
- There is no sign-in: the server only answers on your own computer, at http://127.0.0.1:8787/mcp.
- Apps that run in the cloud, like claude.ai, ChatGPT and Kazi, can’t reach a server on your computer. Use them with the hosted address instead.
- Your agent reads footage from your Movies folder (~/Movies, read-only) and writes finished videos to ~/cuttingfloor/exports. Change either in a .env file next to compose.yaml (see .env.example).
- The command-only setup forwards to the running container, so a long export keeps going after your app closes.
- To try it with nothing of your own, the image includes a 10-second test clip and a picture: /samples/sample.mp4 and /samples/card.png.

Cursor and other apps that use mcpServers:

```
{
  "mcpServers": {
    "cuttingfloor": {
      "url": "http://127.0.0.1:8787/mcp"
    }
  }
}
```

Claude Code, in a terminal:

```
claude mcp add --transport http cuttingfloor http://127.0.0.1:8787/mcp
```

Apps that only start a command (for example claude_desktop_config.json):

```
{
  "mcpServers": {
    "cuttingfloor": {
      "command": "docker",
      "args": [
        "exec",
        "-i",
        "cuttingfloor",
        "cuttingfloor",
        "mcp"
      ]
    }
  }
}
```

## Hosted or yourself

Same code. Nothing is held back when you run it yourself; paying for hosted buys one thing: we run it.

| | Hosted (cuttingfloor.ai) | Run it yourself |
|---|---|---|
| The software | The same Docker image, run by us. | The same Docker image (ghcr.io/mvp2o-ai/cuttingfloor), run by you. |
| Updates | We do them. You always have the newest tools. | You do, when you want: git pull, then docker compose pull, then docker compose up -d. |
| Machines | Ours. Nothing to install; rendering, transcripts and cutouts run on our servers. | Yours: your computer or a server you run, with Docker. |
| Render limits | Your plan’s render minutes each month, plus its jobs at once, video size and storage. When minutes run out, new jobs wait; you’re never charged more than the plan. | None but your machine. How many jobs run at once follows your computer’s cores, and you can change it. |
| Keys | None, except your own sync. labs key for lip-sync. | Your own sync. labs key for lip-sync, and a TypeSafe key for visual judgment. Everything else needs none. |
| Storage and time limits | On our servers, for a while: timelines for a day after you last use them, media and renders for 7 days, download links for 24 hours. Download what you want to keep. | On your machine, with the same time limits inside Docker. Finished exports also land in a folder on your computer, and stay there. |
| Sign-in | Your agent opens the cuttingfloor sign-in. Scripts use a key from your account page (cf_…). | None. It only answers on your own computer. |
| Cost | A monthly plan, after 3 days free. Editing is free; you pay for render minutes. | Free. You pay for your own computer, and for any key you choose to add. |

## Keys

| Feature | Hosted | Run it yourself |
|---|---|---|
| Lip-sync (redraw a speaker’s mouth to new words) | Your own sync. labs key, saved on your account page or sent as a header. sync. labs bills you per second. | Your own sync. labs key as SYNC_API_KEY. |
| Visual judgment: questions about frames, looking across a video, finding moments in plain words | Included. No key. | A TypeSafe key as TYPESAFE_API_KEY (typesafe.ai). |

Built in, no key, either way:

- Transcripts with word times (whisper.cpp)
- Voiceover with timed words (Kokoro)
- Background removal for people or any subject (MODNet, BiRefNet)
- Voice, drums, bass and music split apart (Demucs)
- Stabilizing shaky footage (vid.stab)
- Motion graphics and stills from HTML, with transparency
- Beats, faces, object tracking, silences and scene changes
- Every edit, effect, caption, mix and export (FFmpeg and MLT)

Running it yourself, keys go in the .env file next to compose.yaml. Run `docker compose up -d` after adding one.

## What AGPL-3.0 means for you

- **Use it.** Free, for anyone. Run it on your own computer for your own videos, or for your company. No fee and no seat count.
- **Change it.** Fork it, change anything, and run your changed version yourself.
- **Share your changes if you offer it to others.** If you let other people use a changed version over a network (for example, you host it for customers), you have to offer them your changed source code, under the same licence (AGPL-3.0).
- **The fine print.** This is a plain-words summary, not legal advice. The licence text in the repository is what counts.

## What you need

- Docker (Docker Desktop, or Docker Engine on Linux). It’s the only thing you install: the editing engines and models are inside the image.
- A copy of the repository, from git clone. Compose needs the sandbox’s security profile that comes with it (tools/motion/seccomp.json).
- Memory: background removal for any subject (BiRefNet) needs about 3 GB free for Docker. The motion graphics sandbox can use up to 4 GB and 4 CPU cores.
- On Docker Desktop for Mac, raise the memory limit for long 4K timelines.
- The first transcript and the first voiceover download their models once (the voice model is about 350 MB).
- On Linux, create the exports folder before the first start, so it belongs to you.

To update later: `git pull && docker compose pull && docker compose up -d`

## Make it your own

The code, issues and releases are on GitHub: https://github.com/mvp2o-ai/cuttingfloor. To send a change, read CONTRIBUTING.md (https://github.com/mvp2o-ai/cuttingfloor/blob/HEAD/CONTRIBUTING.md): fork it, branch from develop and open a pull request.