FrameJam

Make videos with your coding agent, and tell it what to change by pointing at the screen.

Pick a style, let the agent build the video, then click the frame that's wrong and say why. Your agent gets the exact timestamp and a frame image with your pin on the spot you clicked.

Website · Join the Discord · Get updates · Report an issue

Why FrameJam

Coding agents are surprisingly good at making videos, with Hyperframes, Remotion, Motion Canvas, ffmpeg or whatever your project already uses. The hard part is everything around it. Describing a look in words is slow, and "the thing at around three seconds should be bigger" is a terrible way to give feedback. FrameJam is a plugin for Claude, ChatGPT and Cursor, with a small app that sits next to your agent, and it handles both.

Pick a style instead of describing one. Name one of 30 example videos when you ask for a video, or type /framejam:style to choose on a page. Your agent gets the look: palette, textures, fonts, easing, transitions, text animations and pacing, and builds whatever your video is about in it.

Give feedback like you would to a person. Pause and type, click the thing that's off, or drag across the timeline to mark a range. Press Finish review and your agent gets every comment with its timestamp and a frame from the render, with your pin drawn where you clicked.

Works with any video tool. Anything that renders an mp4 can be reviewed, and you always review the render.

Go round by round. Each new version from the agent is a fresh round. Old versions keep their comments, so you can always see what changed and why.

Runs on your machine. One local Node process, no account, no upload. Your projects are plain JSON files in ~/.framejam. Your videos and comments never leave your machine. The Styles and Playbooks pages stream their example videos from framejam.ai, and the Feedback button sends the note you write; nothing else goes out.

How it works

1. Ask your agent for a video, for example "make a 7-second launch teaser with FrameJam and open it for review".
2. Optionally pick a playbook and a style: name them in your request, or type /framejam:playbook or /framejam:style to choose on a page.
3. Review it in the browser pane next to your chat: click, type, drag, then press Finish review.
4. Get version 2. The agent applies your notes and the page switches to the new version on its own. Repeat until you love it.

Not ready to animate yet? Ask for a storyboard first: one still per shot, which you review the same way.

Quick start

FrameJam is a plugin for Claude Code (terminal and the Claude desktop app), ChatGPT (Work and Codex in the ChatGPT desktop app) and Cursor. You need Node 22+ and ffmpeg (brew install ffmpeg on macOS). Paste this into your agent (shown for Cursor; use claude or codex for the other apps):

Run npx -y framejam install cursor and open the link it prints in your built-in browser.

Or run npx -y framejam install in a terminal yourself; without an app name it sets up every app it finds. It installs the FrameJam plugin in each app (the tools and the skill), checks Node and ffmpeg, and starts the app in the background at http://localhost:2400. Then start a new session in Claude, reopen the ChatGPT app, or reload the Cursor window, so the plugin loads. FrameJam shows up in each app's plugin list, where you can turn it off or remove it.

Updating. In Claude Code the plugin updates on its own. Run npx -y framejam@latest install any time to update everywhere: it updates the plugin and replaces an older FrameJam UI that is still running in the background with the new one. The Projects page shows a notice with this command when a newer version is on npm (it asks the npm registry at most every 6 hours; set FRAMEJAM_NO_UPDATE_CHECK=1 to turn that off).

After that, typing /framejam:start in your agent is all it takes: the agent opens FrameJam and picks up where you are (a video you're already editing, feedback waiting, or a new video). Until an agent has connected, the start page shows a short setup checklist (it stays available at /setup). After that, it lists your projects and shows whose turn it is on each one.

To run from a clone instead:

git clone https://github.com/moritzkremb/framejam.git
cd framejam
npm install
npm run build
npm start                 # http://localhost:2400  (MCP at http://localhost:2400/mcp)
node dist/server/cli.js install   # points your apps at this clone instead of npm (MCP server + skill, no plugin)

Connect your agent

npx -y framejam install does all of this for you. The plugin lives in plugin/: one folder that Claude Code, ChatGPT and Cursor all read, listed in this repo's marketplaces (.claude-plugin/marketplace.json for Claude, .agents/plugins/marketplace.json for ChatGPT). To install it by hand, then run npx -y framejam start to start the UI:

In Claude Code:

/plugin install framejam --marketplace moritzkremb/framejam

Or in a terminal:

claude plugin marketplace add moritzkremb/framejam
claude plugin install framejam@framejam

In the Claude desktop app you can also add the marketplace under Customize → Plugins → Add → Add marketplace → Add from a repository. Start a new session so it loads. Claude Code has no built-in browser, so open http://localhost:2400 yourself.

codex plugin marketplace add moritzkremb/framejam
codex plugin add framejam@framejam

The codex command comes with the ChatGPT desktop app. Reopen the app; FrameJam is listed under Plugins.

Cursor also loads plugins you installed in Claude Code, so if you have FrameJam there, you're done. Otherwise copy the plugin folder to ~/.cursor/plugins/local/framejam and reload the window.

Each app needs the MCP server and the skill. Desktop apps launched from the Dock may not see the PATH from your shell (nvm, fnm): if the server fails to start because npx isn't found, use the full path from which npx as the command. When running from a clone, replace npx -y framejam with node /absolute/path/to/framejam/dist/server/cli.js and moritzkremb/framejam with the clone's path.

For example, in Cursor's ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "framejam": {
      "command": "npx",
      "args": ["-y", "framejam", "--stdio"]
    }
  }
}

npx -y skills add moritzkremb/framejam -g -a cursor -y

Claude Code: claude mcp add -s user framejam -- npx -y framejam --stdio. Codex: codex mcp add framejam -- npx -y framejam --stdio. Use -a claude-code or -a codex for the skill.

ChatGPT's chat connectors use MCP over HTTP. Run npm start, turn on developer mode for connectors in ChatGPT's settings, and add a custom connector with this URL:

http://localhost:2400/mcp

If your ChatGPT build requires an https URL, expose the port with a tunnel (for example cloudflared tunnel --url http://localhost:2400) and set FRAMEJAM_PUBLIC_URL to the tunnel URL so the review links it hands out are reachable.

skills/framejam/SKILL.md is the skill. The plugin ships it as start (so the command reads /framejam:start), next to playbook and style. Without the plugin, npx skills add moritzkremb/framejam installs it for most agents (there it's /framejam); you can also drop it into AGENTS.md. It walks the agent through: ask what to make → pick a preset → build with the project's tool → render → open_review → wait_for_feedback (and call it again while the result is pending, up to 12 times in a row, about 10 minutes) → edit → add_version with a note, until you say it's done. .cursor/rules/framejam.mdc is the same text as a Cursor rule; regenerate it with npm run sync:rule after editing the skill.

Try the whole loop without an agent

npm start                 # terminal 1
npm run e2e               # terminal 2 — plays the agent: picks a preset, opens a review, blocks on wait_for_feedback

Open the printed review URL, add a few comments and press Finish review. The script prints what the agent received, then posts v2, and you can watch the page move to it live. npx tsx scripts/ui-demo.ts does the browser side automatically (headless Chrome) and saves screenshots.

Styles